Generated JavaScript API

Modules

concerto-core: Concerto core module. Concerto is a framework for defining domain specific models.
concerto-cto: Concerto CTO concrete syntax module. Concerto is a framework for defining domain specific models.
concerto-metamodel: Concerto metamodel management. Concerto is a framework for defining domain specific models.
concerto-tools: Concerto Tools module.
concerto-util: Concerto utility module. Concerto is a framework for defining domain specific models.
concerto-vocabulary: Concerto vocabulary module. Concerto is a framework for defining domain specific models.

Classes

AbstractPlugin: Simple plug-in class for code-generation. This lists functions that can be passed to extend the default code-generation behavior.
EmptyPlugin: Simple plug-in class for code-generation. This lists functions that can be passed to extend the default code-generation behavior.

Constants

rootModelAst : unknown
metaModelCto: The metamodel itself, as a CTO string
metaModelAst : unknown: The metamodel itself, as an AST.
MetaModelNamespace: The namespace for the metamodel
metaModelCto: The metamodel itself, as a CTO string
levels : Object: Default levels for the npm configuration.
colorMap : Object: Default levels for the npm configuration.

Functions

setCurrentTime([currentTime], [utcOffset]) ⇒ object: Ensures there is a proper current time
newMetaModelManager() ⇒ ModelManager: Create a metamodel manager (for validation against the metamodel)
validateMetaModel(input) ⇒ object: Validate metamodel instance against the metamodel
modelManagerFromMetaModel(metaModel, [validate]) ⇒ ModelManager: Import metamodel to a model manager
getRootModel(versioned) ⇒ object: Gets the root 'concerto' model
randomNumberInRangeWithPrecision(userMin, userMax, precision, systemMin, systemMax) ⇒ number: Generate a random number within a given range with a prescribed precision and inside a global range
updateModels(models, newModel) ⇒ *: Update models with a new model
resolveExternal(models, [options], [fileDownloader]) ⇒ Promise: Downloads all ModelFiles that are external dependencies and adds or updates them in this ModelManager.
parse(cto, [fileName], [options]) ⇒ object: Create a metamodel instance (i.e. JSON AST) object from a CTO string
parseModels(files, [options]) ⇒ *: Parses an array of model files
decoratorArgFromMetaModel(mm) ⇒ string: Create decorator argument string from a metamodel
decoratorFromMetaModel(mm) ⇒ string: Create decorator string from a metamodel
decoratorsFromMetaModel(mm, prefix) ⇒ string: Create decorators string from a metamodel
typeFromMetaModel(mm) ⇒ string: Create type string from a metamodel
modifiersFromMetaModel(mm) ⇒ string: Create modifiers string from a metamodel
propertyFromMetaModel(mm) ⇒ string: Create a property string from a metamodel
declFromMetaModel(mm) ⇒ string: Create a declaration string from a metamodel
toCTO(metaModel) ⇒ string: Create a model string from a metamodel
findNamespace(priorModels, namespace) ⇒ *: Find the model for a given namespace
findDeclaration(thisModel, name) ⇒ *: Find a declaration for a given name in a model
createNameTable(priorModels, metaModel) ⇒ object: Create a name resolution table
resolveName(name, table) ⇒ string: Resolve a name using the name table
resolveTypeNames(metaModel, table) ⇒ object: Name resolution for metamodel
resolveLocalNames(priorModels, metaModel) ⇒ object: Resolve the namespace for names in the metamodel
resolveLocalNamesForAll(allModels) ⇒ object: Resolve the namespace for names in the metamodel
inferModelFile(defaultNamespace, defaultType, schema, options) ⇒ string: Infers a Concerto model from a JSON Schema.
capitalizeFirstLetter(string) ⇒ string: Capitalize the first letter of a string
hashCode(value) ⇒ number: Computes an integer hashcode value for a string
isObject(val) ⇒ Boolean: Returns true if val is an object
isBoolean(val) ⇒ Boolean: Returns true if val is a boolean
isNull(val) ⇒ Boolean: Returns true if val is null
isArray(val) ⇒ Boolean: Returns true if val is an array
isString(val) ⇒ Boolean: Returns true if val is a string
isDateTime(val) ⇒ Boolean: Returns true if val is a date time
isInteger(val) ⇒ Boolean: Returns true if val is an integer
isDouble(val) ⇒ Boolean: Returns true if val is an integer
getType(input) ⇒ string: Get the primitive Concerto type for an input
handleArray(typeName, context, input) ⇒ object: Handles an array
handleType(name, context, input) ⇒ object: Handles an input type
removeDuplicateTypes(context): Detect duplicate types and remove them
inferModel(namespace, rootTypeName, input) ⇒ string: Infers a Concerto model from a JSON instance.
main(): Generate TypeScript files from the metamodel.
labelToSentence(labelName) ⇒ string: Inserts correct spacing and capitalization to a camelCase label
sentenceToLabel(sentence) ⇒ string: Create a camelCase label from a sentence
writeModelsToFileSystem(files, path, options): Writes a set of model files to disk
camelCaseToSentence(text) ⇒ string: Converts a camel case string to a sentence

Typedefs

ParseNamespaceResult

concerto-core

Concerto core module. Concerto is a framework for defining domain specific models.

concerto-core
- static
  - .AstModelManager
    - new AstModelManager([options])
  - .BaseModelManager
    - new BaseModelManager([options], [processFile])
    - .isModelManager() ⇒ boolean
    - .isStrict() ⇒ boolean
    - .accept(visitor, parameters) ⇒ Object
    - .validateModelFile(modelFile, [fileName])
    - .addModelFile(modelFile, [cto], [fileName], [disableValidation]) ⇒ Object
    - .addModel(modelInput, [cto], [fileName], [disableValidation]) ⇒ ModelFile
    - .updateModelFile(modelFile, [fileName], [disableValidation]) ⇒ Object
    - .deleteModelFile(namespace)
    - .addModelFiles(modelFiles, [fileNames], [disableValidation]) ⇒ Array.<Object>
    - .validateModelFiles()
    - .updateExternalModels([options], [fileDownloader]) ⇒ Promise
    - .writeModelsToFileSystem(path, [options])
    - .getModels([options]) ⇒ Array.<{name:string, content:string}>
    - .clearModelFiles()
    - .getModelFile(namespace) ⇒ ModelFile
    - .getNamespaces() ⇒ Array.<string>
    - .getType(qualifiedName) ⇒ ClassDeclaration
    - .getAssetDeclarations() ⇒ Array.<AssetDeclaration>
    - .getTransactionDeclarations() ⇒ Array.<TransactionDeclaration>
    - .getEventDeclarations() ⇒ Array.<EventDeclaration>
    - .getParticipantDeclarations() ⇒ Array.<ParticipantDeclaration>
    - .getEnumDeclarations() ⇒ Array.<EnumDeclaration>
    - .getConceptDeclarations() ⇒ Array.<ConceptDeclaration>
    - .getFactory() ⇒ Factory
    - .getSerializer() ⇒ Serializer
    - .getDecoratorFactories() ⇒ Array.<DecoratorFactory>
    - .addDecoratorFactory(factory)
    - .derivesFrom(fqt1, fqt2) ⇒ boolean
    - .resolveMetaModel(metaModel) ⇒ object
    - .fromAst(ast)
    - .getAst([resolve]) ⇒ *
  - .Concerto
    - new Concerto(modelManager)
    - .validate(obj, [options])
    - .getModelManager() ⇒ ModelManager
    - .isObject(obj) ⇒ boolean
    - .getTypeDeclaration(obj) ⇒ *
    - .getIdentifier(obj) ⇒ string
    - .isIdentifiable(obj) ⇒ boolean
    - .isRelationship(obj) ⇒ boolean
    - .setIdentifier(obj, id) ⇒ *
    - .getFullyQualifiedIdentifier(obj) ⇒ string
    - .toURI(obj) ⇒ string
    - .fromURI(uri) ⇒ *
    - .getType(obj) ⇒ string
    - .getNamespace(obj) ⇒ string
  - .DecoratorManager
    - .decorateModels(modelManager, decoratorCommandSet) ⇒ ModelManager
    - .falsyOrEqual(test, value) ⇒ Boolean
    - .applyDecorator(decorated, type, newDecorator)
    - .executeCommand(namespace, declaration, command)
  - .Factory
    - new Factory(modelManager)
    - instance
      - .newResource(ns, type, [id], [options]) ⇒ Resource
      - .newConcept(ns, type, [id], [options]) ⇒ Resource
      - .newRelationship(ns, type, id) ⇒ Relationship
      - .newTransaction(ns, type, [id], [options]) ⇒ Resource
      - .newEvent(ns, type, [id], [options]) ⇒ Resource
    - static
      - .newId() ⇒ string
  - .AssetDeclaration ⇐ ClassDeclaration
    - new AssetDeclaration(modelFile, ast)
    - .declarationKind() ⇒ string
  - .ClassDeclaration
    - new ClassDeclaration(modelFile, ast)
    - .getModelFile() ⇒ ModelFile
    - ._resolveSuperType() ⇒ ClassDeclaration
    - .validate()
    - .isAbstract() ⇒ boolean
    - .getName() ⇒ string
    - .getNamespace() ⇒ string
    - .getFullyQualifiedName() ⇒ string
    - .isIdentified() ⇒ Boolean
    - .isSystemIdentified() ⇒ Boolean
    - .isExplicitlyIdentified() ⇒ Boolean
    - .getIdentifierFieldName() ⇒ string
    - .getOwnProperty(name) ⇒ Property
    - .getOwnProperties() ⇒ Array.<Property>
    - .getSuperType() ⇒ string
    - .getSuperTypeDeclaration() ⇒ ClassDeclaration
    - .getAssignableClassDeclarations() ⇒ Array.<ClassDeclaration>
    - .getDirectSubclasses() ⇒ Array.<ClassDeclaration>
    - .getAllSuperTypeDeclarations() ⇒ Array.<ClassDeclaration>
    - .getProperty(name) ⇒ Property
    - .getProperties() ⇒ Array.<Property>
    - .getNestedProperty(propertyPath) ⇒ Property
    - .toString() ⇒ String
    - .isAsset() ⇒ boolean
    - .isParticipant() ⇒ boolean
    - .isTransaction() ⇒ boolean
    - .isEvent() ⇒ boolean
    - .isConcept() ⇒ boolean
    - .isEnum() ⇒ boolean
    - .isClassDeclaration() ⇒ boolean
  - .ConceptDeclaration ⇐ ClassDeclaration
    - new ConceptDeclaration(modelFile, ast)
    - .declarationKind() ⇒ string
  - .Decorator
    - new Decorator(parent, ast)
    - .getParent() ⇒ ClassDeclaration | Property
    - .getName() ⇒ string
    - .getArguments() ⇒ Array.<object>
    - .isDecorator() ⇒ boolean
  - .DecoratorFactory
    - .newDecorator(parent, ast) ⇒ Decorator
  - .EnumDeclaration ⇐ ClassDeclaration
    - new EnumDeclaration(modelFile, ast)
    - .toString() ⇒ String
    - .declarationKind() ⇒ string
  - .EnumValueDeclaration ⇐ Property
    - new EnumValueDeclaration(parent, ast)
    - .isEnumValue() ⇒ boolean
  - .EventDeclaration ⇐ ClassDeclaration
    - new EventDeclaration(modelFile, ast)
    - .declarationKind() ⇒ string
  - .IdentifiedDeclaration ⇐ ClassDeclaration
    - new IdentifiedDeclaration(modelFile, ast)
  - .IllegalModelException ⇐ BaseFileException
    - new IllegalModelException(message, [modelFile], [fileLocation], [component])
  - .Introspector
    - new Introspector(modelManager)
    - .getClassDeclarations() ⇒ Array.<ClassDeclaration>
    - .getClassDeclaration(fullyQualifiedTypeName) ⇒ ClassDeclaration
  - .ModelFile
    - new ModelFile(modelManager, ast, [definitions], [fileName])
    - .getModelFile() ⇒ ModelFile
    - .isModelFile() ⇒ boolean
    - .getVersion() ⇒ string
    - .isSystemModelFile() ⇒ Boolean
    - .isExternal() ⇒ boolean
    - .getModelManager() ⇒ ModelManager
    - .getImports() ⇒ Array.<string>
    - .validate()
    - .isDefined(type) ⇒ boolean
    - .getLocalType(type) ⇒ ClassDeclaration
    - .getAssetDeclaration(name) ⇒ AssetDeclaration
    - .getTransactionDeclaration(name) ⇒ TransactionDeclaration
    - .getEventDeclaration(name) ⇒ EventDeclaration
    - .getParticipantDeclaration(name) ⇒ ParticipantDeclaration
    - .getNamespace() ⇒ string
    - .getName() ⇒ string
    - .getAssetDeclarations() ⇒ Array.<AssetDeclaration>
    - .getTransactionDeclarations() ⇒ Array.<TransactionDeclaration>
    - .getEventDeclarations() ⇒ Array.<EventDeclaration>
    - .getParticipantDeclarations() ⇒ Array.<ParticipantDeclaration>
    - .getConceptDeclarations() ⇒ Array.<ConceptDeclaration>
    - .getEnumDeclarations() ⇒ Array.<EnumDeclaration>
    - .getScalarDeclarations() ⇒ Array.<ScalarDeclaration>
    - .getDeclarations(type) ⇒ Array.<Object>
    - .getAllDeclarations() ⇒ Array.<ClassDeclaration>
    - .getDefinitions() ⇒ string
    - .getAst() ⇒ object
    - .getConcertoVersion() ⇒ string
    - .isCompatibleVersion()
    - .enforceImportVersioning(imp)
  - .ParticipantDeclaration ⇐ ClassDeclaration
    - new ParticipantDeclaration(modelFile, ast)
    - .declarationKind() ⇒ string
  - .Property
    - new Property(parent, ast)
    - .getModelFile() ⇒ ModelFile
    - .getParent() ⇒ ClassDeclaration
    - .validate(classDecl)
    - .getName() ⇒ string
    - .getType() ⇒ string
    - .isOptional() ⇒ boolean
    - .getFullyQualifiedTypeName() ⇒ string
    - .getFullyQualifiedName() ⇒ string
    - .getNamespace() ⇒ string
    - .isArray() ⇒ boolean
    - .isTypeEnum() ⇒ boolean
    - .isPrimitive() ⇒ boolean
  - .RelationshipDeclaration ⇐ Property
    - new RelationshipDeclaration(parent, ast)
    - .validate(classDecl)
    - .toString() ⇒ String
    - .isRelationship() ⇒ boolean
  - .ScalarDeclaration
    - new ScalarDeclaration(modelFile, ast)
    - .getModelFile() ⇒ ModelFile
    - .validate()
    - .getName() ⇒ string
    - .getNamespace() ⇒ string
    - .getFullyQualifiedName() ⇒ string
    - .isIdentified() ⇒ Boolean
    - .isSystemIdentified() ⇒ Boolean
    - .getIdentifierFieldName() ⇒ null
    - .getType() ⇒ string
    - .getSuperType()
    - .getSuperTypeDeclaration() ⇒ ScalarDeclaration | null
    - .getValidator() ⇒ Validator
    - .getDefaultValue() ⇒ string | number | null
    - .toString() ⇒ String
    - .isAbstract() ⇒ boolean
    - .isAsset() ⇒ boolean
    - .isParticipant() ⇒ boolean
    - .isTransaction() ⇒ boolean
    - .isEvent() ⇒ boolean
    - .isConcept() ⇒ boolean
    - .isEnum() ⇒ boolean
    - .isClassDeclaration() ⇒ boolean
    - .isScalarDeclaration() ⇒ boolean
  - .TransactionDeclaration ⇐ ClassDeclaration
    - new TransactionDeclaration(modelFile, ast)
    - .declarationKind() ⇒ string
  - .Identifiable ⇐ Typed
    - new Identifiable(modelManager, classDeclaration, ns, type, id, timestamp)
    - .getTimestamp() ⇒ string
    - .getIdentifier() ⇒ string
    - .setIdentifier(id)
    - .getFullyQualifiedIdentifier() ⇒ string
    - .toString() ⇒ String
    - .isRelationship() ⇒ boolean
    - .isResource() ⇒ boolean
    - .toURI() ⇒ String
  - .Resource ⇐ Identifiable
    - new Resource(modelManager, classDeclaration, ns, type, id, timestamp)
    - .toString() ⇒ String
    - .isResource() ⇒ boolean
    - .isConcept() ⇒ boolean
    - .isIdentifiable() ⇒ boolean
    - .toJSON() ⇒ Object
  - .Typed
    - new Typed(modelManager, classDeclaration, ns, type)
    - .getType() ⇒ string
    - .getFullyQualifiedType() ⇒ string
    - .getNamespace() ⇒ string
    - .setPropertyValue(propName, value)
    - .addArrayValue(propName, value)
    - .instanceOf(fqt) ⇒ boolean
    - .toJSON()
  - .ModelLoader
    - .loadModelManager(ctoFiles, options) ⇒ Promise.<ModelManager>
    - .loadModelManagerFromModelFiles(modelFiles, [fileNames], options) ⇒ Promise.<ModelManager>
  - .ModelManager
    - new ModelManager([options])
    - .addCTOModel(cto, [fileName], [disableValidation]) ⇒ ModelFile
  - .SecurityException ⇐ BaseException
    - new SecurityException(message)
  - .Serializer
    - new Serializer(factory, modelManager, [options])
    - .setDefaultOptions(newDefaultOptions)
    - .toJSON(resource, [options]) ⇒ Object
    - .fromJSON(jsonObject, [options]) ⇒ Resource
  - .TypeNotFoundException ⇐ BaseException
    - new TypeNotFoundException(typeName, message, component)
    - .getTypeName() ⇒ string
  - .BaseException ⇐ Error
    - new BaseException(message, component)
  - .BaseFileException ⇐ BaseException
    - new BaseFileException(message, fileLocation, fullMessage, [fileName], [component])
    - .getFileLocation() ⇒ string
    - .getShortMessage() ⇒ string
    - .getFileName() ⇒ string
  - .FileDownloader
    - new FileDownloader(fileLoader, getExternalImports, concurrency)
    - .downloadExternalDependencies(files, [options]) ⇒ Promise
    - .runJob(job, fileLoader) ⇒ Promise
  - .TypedStack
    - new TypedStack(resource)
    - .push(obj, expectedType)
    - .pop(expectedType) ⇒ Object
    - .peek(expectedType) ⇒ Object
    - .clear()
- inner
  - ~version : Object

concerto-core.AstModelManager

Manages the Concerto model files in AST format.

The structure of Resources (Assets, Transactions, Participants) is modelled in a set of Concerto files. The contents of these files are managed by the ModelManager. Each Concerto file has a single namespace and contains a set of asset, transaction and participant type definitions.

Concerto applications load their Concerto files and then call the addModelFile method to register the Concerto file(s) with the ModelManager.

Kind: static class of concerto-core

new AstModelManager([options])

Create the ModelManager.

Param	Type	Description
[options]	`object`	Serializer options

concerto-core.BaseModelManager

Manages the Concerto model files.

Concerto applications load their Concerto files and then call the addModelFile method to register the Concerto file(s) with the ModelManager.

Use the Concerto class to validate instances.

Kind: static class of concerto-core

.BaseModelManager
- new BaseModelManager([options], [processFile])
- .isModelManager() ⇒ boolean
- .isStrict() ⇒ boolean
- .accept(visitor, parameters) ⇒ Object
- .validateModelFile(modelFile, [fileName])
- .addModelFile(modelFile, [cto], [fileName], [disableValidation]) ⇒ Object
- .addModel(modelInput, [cto], [fileName], [disableValidation]) ⇒ ModelFile
- .updateModelFile(modelFile, [fileName], [disableValidation]) ⇒ Object
- .deleteModelFile(namespace)
- .addModelFiles(modelFiles, [fileNames], [disableValidation]) ⇒ Array.<Object>
- .validateModelFiles()
- .updateExternalModels([options], [fileDownloader]) ⇒ Promise
- .writeModelsToFileSystem(path, [options])
- .getModels([options]) ⇒ Array.<{name:string, content:string}>
- .clearModelFiles()
- .getModelFile(namespace) ⇒ ModelFile
- .getNamespaces() ⇒ Array.<string>
- .getType(qualifiedName) ⇒ ClassDeclaration
- .getAssetDeclarations() ⇒ Array.<AssetDeclaration>
- .getTransactionDeclarations() ⇒ Array.<TransactionDeclaration>
- .getEventDeclarations() ⇒ Array.<EventDeclaration>
- .getParticipantDeclarations() ⇒ Array.<ParticipantDeclaration>
- .getEnumDeclarations() ⇒ Array.<EnumDeclaration>
- .getConceptDeclarations() ⇒ Array.<ConceptDeclaration>
- .getFactory() ⇒ Factory
- .getSerializer() ⇒ Serializer
- .getDecoratorFactories() ⇒ Array.<DecoratorFactory>
- .addDecoratorFactory(factory)
- .derivesFrom(fqt1, fqt2) ⇒ boolean
- .resolveMetaModel(metaModel) ⇒ object
- .fromAst(ast)
- .getAst([resolve]) ⇒ *

new BaseModelManager([options], [processFile])

Create the ModelManager.

Param	Type	Description
[options]	`object`	ModelManager options, also passed to Serializer
[options.strict]	`boolean`	require versioned namespaces and imports
[options.regExp]	`Object`	An alternative regular expression engine.
[processFile]	`*`	how to obtain a concerto AST from an input to the model manager

baseModelManager.isModelManager() ⇒ `boolean`

Returns true

Kind: instance method of BaseModelManager
Returns: boolean - true

baseModelManager.isStrict() ⇒ `boolean`

Returns the value of the strict option

Kind: instance method of BaseModelManager
Returns: boolean - true if the strict has been set

baseModelManager.accept(visitor, parameters) ⇒ `Object`

Visitor design pattern

Kind: instance method of BaseModelManager
Returns: Object - the result of visiting or null

Param	Type	Description
visitor	`Object`	the visitor
parameters	`Object`	the parameter

baseModelManager.validateModelFile(modelFile, [fileName])

Validates a Concerto file (as a string) to the ModelManager. Concerto files have a single namespace.

Note that if there are dependencies between multiple files the files must be added in dependency order, or the addModelFiles method can be used to add a set of files irrespective of dependencies.

Kind: instance method of BaseModelManager
Throws:

IllegalModelException

Param	Type	Description
modelFile	`string` \| `ModelFile`	The Concerto file as a string
[fileName]	`string`	a file name to associate with the model file

baseModelManager.addModelFile(modelFile, [cto], [fileName], [disableValidation]) ⇒ `Object`

Adds a Concerto file (as an AST) to the ModelManager. Concerto files have a single namespace. If a Concerto file with the same namespace has already been added to the ModelManager then it will be replaced. Note that if there are dependencies between multiple files the files must be added in dependency order, or the addModelFiles method can be used to add a set of files irrespective of dependencies.

Kind: instance method of BaseModelManager
Returns: Object - The newly added model file (internal).
Throws:

IllegalModelException

Param	Type	Description
modelFile	`ModelFile`	Model as a ModelFile object
[cto]	`string`	an optional cto string
[fileName]	`string`	an optional file name to associate with the model file
[disableValidation]	`boolean`	If true then the model files are not validated

baseModelManager.addModel(modelInput, [cto], [fileName], [disableValidation]) ⇒ `ModelFile`

Adds a model to the ModelManager. Concerto files have a single namespace. If a Concerto file with the same namespace has already been added to the ModelManager then it will be replaced. Note that if there are dependencies between multiple files the files must be added in dependency order, or the addModel method can be used to add a set of files irrespective of dependencies.

Kind: instance method of BaseModelManager
Returns: ModelFile - The newly added model file (internal).
Throws:

IllegalModelException

Param	Type	Description
modelInput	`*`	Model (as a string or object)
[cto]	`string`	an optional cto string
[fileName]	`string`	an optional file name to associate with the model file
[disableValidation]	`boolean`	If true then the model files are not validated

baseModelManager.updateModelFile(modelFile, [fileName], [disableValidation]) ⇒ `Object`

Updates a Concerto file (as a string) on the ModelManager. Concerto files have a single namespace. If a Concerto file with the same namespace has already been added to the ModelManager then it will be replaced.

Kind: instance method of BaseModelManager
Returns: Object - The newly added model file (internal).
Throws:

IllegalModelException

Param	Type	Description
modelFile	`string` \| `ModelFile`	Model as a string or object
[fileName]	`string`	a file name to associate with the model file
[disableValidation]	`boolean`	If true then the model files are not validated

baseModelManager.deleteModelFile(namespace)

Remove the Concerto file for a given namespace

Kind: instance method of BaseModelManager

Param	Type	Description
namespace	`string`	The namespace of the model file to delete.

baseModelManager.addModelFiles(modelFiles, [fileNames], [disableValidation]) ⇒ `Array.<Object>`

Add a set of Concerto files to the model manager.

Kind: instance method of BaseModelManager
Returns: Array.<Object> - The newly added model files (internal).

Param	Type	Description
modelFiles	`Array.<string>` \| `Array.<ModelFile>`	An array of models as strings or ModelFile objects.
[fileNames]	`Array.<string>`	A array of file names to associate with the model files
[disableValidation]	`boolean`	If true then the model files are not validated

baseModelManager.validateModelFiles()

Validates all models files in this model manager

Kind: instance method of BaseModelManager

baseModelManager.updateExternalModels([options], [fileDownloader]) ⇒ `Promise`

Downloads all ModelFiles that are external dependencies and adds or updates them in this ModelManager.

Kind: instance method of BaseModelManager
Returns: Promise - a promise when the download and update operation is completed.
Throws:

IllegalModelException if the models fail validation

Param	Type	Description
[options]	`Object`	Options object passed to ModelFileLoaders
[fileDownloader]	`FileDownloader`	an optional FileDownloader

baseModelManager.writeModelsToFileSystem(path, [options])

Write all models in this model manager to the specified path in the file system

Kind: instance method of BaseModelManager

Param	Type	Description
path	`string`	to a local directory
[options]	`Object`	Options object
options.includeExternalModels	`boolean`	If true, external models are written to the file system. Defaults to true

baseModelManager.getModels([options]) ⇒ `Array.<{name:string, content:string}>`

Gets all the Concerto models

Kind: instance method of BaseModelManager
Returns: Array.<{name:string, content:string}> - the name and content of each CTO file

Param	Type	Description
[options]	`Object`	Options object
options.includeExternalModels	`boolean`	If true, external models are written to the file system. Defaults to true

baseModelManager.clearModelFiles()

Remove all registered Concerto files

Kind: instance method of BaseModelManager

baseModelManager.getModelFile(namespace) ⇒ `ModelFile`

Get the ModelFile associated with a namespace

Kind: instance method of BaseModelManager
Returns: ModelFile - registered ModelFile for the namespace or null

Param	Type	Description
namespace	`string`	the namespace containing the ModelFile

baseModelManager.getNamespaces() ⇒ `Array.<string>`

Get the namespaces registered with the ModelManager.

Kind: instance method of BaseModelManager
Returns: Array.<string> - namespaces - the namespaces that have been registered.

baseModelManager.getType(qualifiedName) ⇒ `ClassDeclaration`

Look up a type in all registered namespaces.

Kind: instance method of BaseModelManager
Returns: ClassDeclaration - - the class declaration for the specified type.
Throws:

TypeNotFoundException - if the type cannot be found or is a primitive type.

Param	Type	Description
qualifiedName	`string`	fully qualified type name.

baseModelManager.getAssetDeclarations() ⇒ `Array.<AssetDeclaration>`

Get the AssetDeclarations defined in this model manager

Kind: instance method of BaseModelManager
Returns: Array.<AssetDeclaration> - the AssetDeclarations defined in the model manager

baseModelManager.getTransactionDeclarations() ⇒ `Array.<TransactionDeclaration>`

Get the TransactionDeclarations defined in this model manager

Kind: instance method of BaseModelManager
Returns: Array.<TransactionDeclaration> - the TransactionDeclarations defined in the model manager

baseModelManager.getEventDeclarations() ⇒ `Array.<EventDeclaration>`

Get the EventDeclarations defined in this model manager

Kind: instance method of BaseModelManager
Returns: Array.<EventDeclaration> - the EventDeclaration defined in the model manager

baseModelManager.getParticipantDeclarations() ⇒ `Array.<ParticipantDeclaration>`

Get the ParticipantDeclarations defined in this model manager

Kind: instance method of BaseModelManager
Returns: Array.<ParticipantDeclaration> - the ParticipantDeclaration defined in the model manager

baseModelManager.getEnumDeclarations() ⇒ `Array.<EnumDeclaration>`

Get the EnumDeclarations defined in this model manager

Kind: instance method of BaseModelManager
Returns: Array.<EnumDeclaration> - the EnumDeclaration defined in the model manager

baseModelManager.getConceptDeclarations() ⇒ `Array.<ConceptDeclaration>`

Get the Concepts defined in this model manager

Kind: instance method of BaseModelManager
Returns: Array.<ConceptDeclaration> - the ConceptDeclaration defined in the model manager

baseModelManager.getFactory() ⇒ `Factory`

Get a factory for creating new instances of types defined in this model manager.

Kind: instance method of BaseModelManager
Returns: Factory - A factory for creating new instances of types defined in this model manager.

baseModelManager.getSerializer() ⇒ `Serializer`

Get a serializer for serializing instances of types defined in this model manager.

Kind: instance method of BaseModelManager
Returns: Serializer - A serializer for serializing instances of types defined in this model manager.

baseModelManager.getDecoratorFactories() ⇒ `Array.<DecoratorFactory>`

Get the decorator factories for this model manager.

Kind: instance method of BaseModelManager
Returns: Array.<DecoratorFactory> - The decorator factories for this model manager.

baseModelManager.addDecoratorFactory(factory)

Add a decorator factory to this model manager.

Kind: instance method of BaseModelManager

Param	Type	Description
factory	`DecoratorFactory`	The decorator factory to add to this model manager.

baseModelManager.derivesFrom(fqt1, fqt2) ⇒ `boolean`

Checks if this fully qualified type name is derived from another.

Kind: instance method of BaseModelManager
Returns: boolean - True if this instance is an instance of the specified fully qualified type name, false otherwise.

Param	Type	Description
fqt1	`string`	The fully qualified type name to check.
fqt2	`string`	The fully qualified type name it is may be derived from.

baseModelManager.resolveMetaModel(metaModel) ⇒ `object`

Resolve the namespace for names in the metamodel

Kind: instance method of BaseModelManager
Returns: object - the resolved metamodel

Param	Type	Description
metaModel	`object`	the MetaModel

baseModelManager.fromAst(ast)

Populates the model manager from a models metamodel AST

Kind: instance method of BaseModelManager

Param	Type	Description
ast	`*`	the metamodel

baseModelManager.getAst([resolve]) ⇒ `*`

Get the full ast (metamodel instances) for a modelmanager

Kind: instance method of BaseModelManager
Returns: * - the metamodel

Param	Type	Description
[resolve]	`boolean`	whether to resolve names

concerto-core.Concerto

Runtime API for Concerto.

Kind: static class of concerto-core

.Concerto
- new Concerto(modelManager)
- .validate(obj, [options])
- .getModelManager() ⇒ ModelManager
- .isObject(obj) ⇒ boolean
- .getTypeDeclaration(obj) ⇒ *
- .getIdentifier(obj) ⇒ string
- .isIdentifiable(obj) ⇒ boolean
- .isRelationship(obj) ⇒ boolean
- .setIdentifier(obj, id) ⇒ *
- .getFullyQualifiedIdentifier(obj) ⇒ string
- .toURI(obj) ⇒ string
- .fromURI(uri) ⇒ *
- .getType(obj) ⇒ string
- .getNamespace(obj) ⇒ string

new Concerto(modelManager)

Create a Concerto instance.

Param	Type	Description
modelManager	`ModelManager`	The this.modelManager to use for validation etc.

concerto.validate(obj, [options])

Validates the instance against its model.

Kind: instance method of Concerto
Throws:

Error - if the instance if invalid with respect to the model

Param	Type	Description
obj	`*`	the input object
[options]	`*`	the validation options

concerto.getModelManager() ⇒ `ModelManager`

Returns the model manager

Kind: instance method of Concerto
Returns: ModelManager - the model manager associated with this Concerto class

concerto.isObject(obj) ⇒ `boolean`

Returns true if the input object is a Concerto object

Kind: instance method of Concerto
Returns: boolean - true if the object has a $class attribute

Param	Type	Description
obj	`*`	the input object

concerto.getTypeDeclaration(obj) ⇒ `*`

Returns the ClassDeclaration for an object, or throws an exception

Kind: instance method of Concerto
Returns: * - the ClassDeclaration for the type
Throw: Error an error if the object does not have a $class attribute

Param	Type	Description
obj	`*`	the input object

concerto.getIdentifier(obj) ⇒ `string`

Gets the identifier for an object

Kind: instance method of Concerto
Returns: string - The identifier for this object

Param	Type	Description
obj	`*`	the input object

concerto.isIdentifiable(obj) ⇒ `boolean`

Returns true if the object has an identifier

Kind: instance method of Concerto
Returns: boolean - is the object has been defined with an identifier in the model

Param	Type	Description
obj	`*`	the input object

concerto.isRelationship(obj) ⇒ `boolean`

Returns true if the object is a relationship. Relationships are strings of the form: 'resource:org.accordproject.Order#001' (a relationship) to the 'Order' identifiable, with the id 001.

Kind: instance method of Concerto
Returns: boolean - true if the object is a relationship

Param	Type	Description
obj	`*`	the input object

concerto.setIdentifier(obj, id) ⇒ `*`

Set the identifier for an object. This method does not mutate the input object, use the return object.

Kind: instance method of Concerto
Returns: * - the input object with the identifier set

Param	Type	Description
obj	`*`	the input object
id	`string`	the new identifier

concerto.getFullyQualifiedIdentifier(obj) ⇒ `string`

Returns the fully qualified identifier for an object

Kind: instance method of Concerto
Returns: string - the fully qualified identifier

Param	Type	Description
obj	`*`	the input object

concerto.toURI(obj) ⇒ `string`

Returns a URI for an object

Kind: instance method of Concerto
Returns: string - the URI for the object

Param	Type	Description
obj	`*`	the input object

concerto.fromURI(uri) ⇒ `*`

Parses a resource URI into typeDeclaration and id components.

Kind: instance method of Concerto
Returns: * - an object with typeDeclaration and id attributes
Throws:

Error if the URI is invalid or the type does not exist in the model manager

Param	Type	Description
uri	`string`	the input URI

concerto.getType(obj) ⇒ `string`

Returns the short type name

Kind: instance method of Concerto
Returns: string - the short type name

Param	Type	Description
obj	`*`	the input object

concerto.getNamespace(obj) ⇒ `string`

Returns the namespace for the object

Kind: instance method of Concerto
Returns: string - the namespace

Param	Type	Description
obj	`*`	the input object

concerto-core.DecoratorManager

Utility functions to work with DecoratorCommandSet

Kind: static class of concerto-core

.DecoratorManager
- .decorateModels(modelManager, decoratorCommandSet) ⇒ ModelManager
- .falsyOrEqual(test, value) ⇒ Boolean
- .applyDecorator(decorated, type, newDecorator)
- .executeCommand(namespace, declaration, command)

DecoratorManager.decorateModels(modelManager, decoratorCommandSet) ⇒ `ModelManager`

Applies all the decorator commands from the DecoratorCommandSet to the ModelManager.

Kind: static method of DecoratorManager
Returns: ModelManager - a new model manager with the decorations applied

Param	Type	Description
modelManager	`ModelManager`	the input model manager
decoratorCommandSet	`*`	the DecoratorCommandSet object

DecoratorManager.falsyOrEqual(test, value) ⇒ `Boolean`

Compares two values. If the first argument is falsy the function returns true.

Kind: static method of DecoratorManager
Returns: Boolean - true if the lhs is falsy or test === value

Param	Type	Description
test	`string` \| `null`	the value to test (lhs)
value	`string`	the value to compare (rhs)

DecoratorManager.applyDecorator(decorated, type, newDecorator)

Applies a decorator to a decorated model element.

Kind: static method of DecoratorManager

Param	Type	Description
decorated	`*`	the type to apply the decorator to
type	`string`	the command type
newDecorator	`*`	the decorator to add

DecoratorManager.executeCommand(namespace, declaration, command)

Executes a Command against a ClassDeclaration, adding decorators to the ClassDeclaration, or its properties, as required.

Kind: static method of DecoratorManager

Param	Type	Description
namespace	`string`	the namespace for the declaration
declaration	`*`	the class declaration
command	`*`	the Command object from the org.accordproject.decoratorcommands model

concerto-core.Factory

Use the Factory to create instances of Resource: transactions, participants and assets.

Kind: static class of concerto-core

.Factory
- new Factory(modelManager)
- instance
  - .newResource(ns, type, [id], [options]) ⇒ Resource
  - .newConcept(ns, type, [id], [options]) ⇒ Resource
  - .newRelationship(ns, type, id) ⇒ Relationship
  - .newTransaction(ns, type, [id], [options]) ⇒ Resource
  - .newEvent(ns, type, [id], [options]) ⇒ Resource
- static
  - .newId() ⇒ string

new Factory(modelManager)

Create the factory.

Param	Type	Description
modelManager	`ModelManager`	The ModelManager to use for this registry

factory.newResource(ns, type, [id], [options]) ⇒ `Resource`

Create a new Resource with a given namespace, type name and id

Kind: instance method of Factory
Returns: Resource - the new instance
Throws:

TypeNotFoundException if the type is not registered with the ModelManager

Param	Type	Description
ns	`String`	the namespace of the Resource
type	`String`	the type of the Resource
[id]	`String`	an optional string identifier
[options]	`Object`	an optional set of options
[options.disableValidation]	`boolean`	pass true if you want the factory to return a Resource instead of a ValidatedResource. Defaults to false.
[options.generate]	`String`	Pass one of: sample return a resource instance with generated sample data. empty return a resource instance with empty property values.
[options.includeOptionalFields]	`boolean`	if `options.generate` is specified, whether optional fields should be generated.

factory.newConcept(ns, type, [id], [options]) ⇒ `Resource`

Create a new Concept with a given namespace and type name

Kind: instance method of Factory
Returns: Resource - the new instance
Throws:

TypeNotFoundException if the type is not registered with the ModelManager

Param	Type	Description
ns	`String`	the namespace of the Concept
type	`String`	the type of the Concept
[id]	`String`	an optional string identifier
[options]	`Object`	an optional set of options
[options.disableValidation]	`boolean`	pass true if you want the factory to return a Concept instead of a ValidatedConcept. Defaults to false.
[options.generate]	`String`	Pass one of: sample return a resource instance with generated sample data. empty return a resource instance with empty property values.
[options.includeOptionalFields]	`boolean`	if `options.generate` is specified, whether optional fields should be generated.

factory.newRelationship(ns, type, id) ⇒ `Relationship`

Create a new Relationship with a given namespace, type and identifier. A relationship is a typed pointer to an instance. I.e the relationship with namespace = 'org.example', type = 'Vehicle' and id = 'ABC' creates a pointer that points at an instance of org.example.Vehicle with the id ABC.

Kind: instance method of Factory
Returns: Relationship - - the new relationship instance
Throws:

TypeNotFoundException if the type is not registered with the ModelManager

Param	Type	Description
ns	`String`	the namespace of the Resource
type	`String`	the type of the Resource
id	`String`	the identifier

factory.newTransaction(ns, type, [id], [options]) ⇒ `Resource`

Create a new transaction object. The identifier of the transaction is set to a UUID.

Kind: instance method of Factory
Returns: Resource - A resource for the new transaction.

Param	Type	Description
ns	`String`	the namespace of the transaction.
type	`String`	the type of the transaction.
[id]	`String`	an optional string identifier
[options]	`Object`	an optional set of options
[options.generate]	`String`	Pass one of: sample return a resource instance with generated sample data. empty return a resource instance with empty property values.
[options.includeOptionalFields]	`boolean`	if `options.generate` is specified, whether optional fields should be generated.

factory.newEvent(ns, type, [id], [options]) ⇒ `Resource`

Create a new event object. The identifier of the event is set to a UUID.

Kind: instance method of Factory
Returns: Resource - A resource for the new event.

Param	Type	Description
ns	`String`	the namespace of the event.
type	`String`	the type of the event.
[id]	`String`	an optional string identifier
[options]	`Object`	an optional set of options
[options.generate]	`String`	Pass one of: sample return a resource instance with generated sample data. empty return a resource instance with empty property values.
[options.includeOptionalFields]	`boolean`	if `options.generate` is specified, whether optional fields should be generated.

Factory.newId() ⇒ `string`

Create a new ID for an object.

Kind: static method of Factory
Returns: string - a new ID

concerto-core.AssetDeclaration ⇐ `ClassDeclaration`

AssetDeclaration defines the schema (aka model or class) for an Asset. It extends ClassDeclaration which manages a set of fields, a super-type and the specification of an identifying field.

Kind: static class of concerto-core
Extends: ClassDeclaration
See: See ClassDeclaration

.AssetDeclaration ⇐ ClassDeclaration
- new AssetDeclaration(modelFile, ast)
- .declarationKind() ⇒ string

new AssetDeclaration(modelFile, ast)

Create an AssetDeclaration.

Throws:

IllegalModelException

Param	Type	Description
modelFile	`ModelFile`	the ModelFile for this class
ast	`Object`	The AST created by the parser

assetDeclaration.declarationKind() ⇒ `string`

Returns the kind of declaration

Kind: instance method of AssetDeclaration
Returns: string - what kind of declaration this is

concerto-core.ClassDeclaration

ClassDeclaration defines the structure (model/schema) of composite data. It is composed of a set of Properties, may have an identifying field, and may have a super-type. A ClassDeclaration is conceptually owned by a ModelFile which defines all the classes that are part of a namespace.

Kind: static abstract class of concerto-core

.ClassDeclaration
- new ClassDeclaration(modelFile, ast)
- .getModelFile() ⇒ ModelFile
- ._resolveSuperType() ⇒ ClassDeclaration
- .validate()
- .isAbstract() ⇒ boolean
- .getName() ⇒ string
- .getNamespace() ⇒ string
- .getFullyQualifiedName() ⇒ string
- .isIdentified() ⇒ Boolean
- .isSystemIdentified() ⇒ Boolean
- .isExplicitlyIdentified() ⇒ Boolean
- .getIdentifierFieldName() ⇒ string
- .getOwnProperty(name) ⇒ Property
- .getOwnProperties() ⇒ Array.<Property>
- .getSuperType() ⇒ string
- .getSuperTypeDeclaration() ⇒ ClassDeclaration
- .getAssignableClassDeclarations() ⇒ Array.<ClassDeclaration>
- .getDirectSubclasses() ⇒ Array.<ClassDeclaration>
- .getAllSuperTypeDeclarations() ⇒ Array.<ClassDeclaration>
- .getProperty(name) ⇒ Property
- .getProperties() ⇒ Array.<Property>
- .getNestedProperty(propertyPath) ⇒ Property
- .toString() ⇒ String
- .isAsset() ⇒ boolean
- .isParticipant() ⇒ boolean
- .isTransaction() ⇒ boolean
- .isEvent() ⇒ boolean
- .isConcept() ⇒ boolean
- .isEnum() ⇒ boolean
- .isClassDeclaration() ⇒ boolean

new ClassDeclaration(modelFile, ast)

Create a ClassDeclaration from an Abstract Syntax Tree. The AST is the result of parsing.

Throws:

IllegalModelException

Param	Type	Description
modelFile	`ModelFile`	the ModelFile for this class
ast	`Object`	the AST created by the parser

classDeclaration.getModelFile() ⇒ `ModelFile`

Returns the ModelFile that defines this class.

Kind: instance method of ClassDeclaration
Returns: ModelFile - the owning ModelFile
Access: public

classDeclaration._resolveSuperType() ⇒ `ClassDeclaration`

Resolve the super type on this class and store it as an internal property.

Kind: instance method of ClassDeclaration
Returns: ClassDeclaration - The super type, or null if non specified.

classDeclaration.validate()

Semantic validation of the structure of this class. Subclasses should override this method to impose additional semantic constraints on the contents/relations of fields.

Kind: instance method of ClassDeclaration
Throws:

IllegalModelException

Access: protected

classDeclaration.isAbstract() ⇒ `boolean`

Returns true if this class is declared as abstract in the model file

Kind: instance method of ClassDeclaration
Returns: boolean - true if the class is abstract

classDeclaration.getName() ⇒ `string`

Returns the short name of a class. This name does not include the namespace from the owning ModelFile.

Kind: instance method of ClassDeclaration
Returns: string - the short name of this class

classDeclaration.getNamespace() ⇒ `string`

Return the namespace of this class.

Kind: instance method of ClassDeclaration
Returns: string - namespace - a namespace.

classDeclaration.getFullyQualifiedName() ⇒ `string`

Returns the fully qualified name of this class. The name will include the namespace if present.

Kind: instance method of ClassDeclaration
Returns: string - the fully-qualified name of this class

classDeclaration.isIdentified() ⇒ `Boolean`

Returns true if this class declaration declares an identifying field (system or explicit)

Kind: instance method of ClassDeclaration
Returns: Boolean - true if the class declaration includes an identifier

classDeclaration.isSystemIdentified() ⇒ `Boolean`

Returns true if this class declaration declares a system identifier $identifier

Kind: instance method of ClassDeclaration
Returns: Boolean - true if the class declaration includes a system identifier

classDeclaration.isExplicitlyIdentified() ⇒ `Boolean`

Returns true if this class declaration declares an explicit identifier

Kind: instance method of ClassDeclaration
Returns: Boolean - true if the class declaration includes an explicit identifier

classDeclaration.getIdentifierFieldName() ⇒ `string`

Returns the name of the identifying field for this class. Note that the identifying field may come from a super type.

Kind: instance method of ClassDeclaration
Returns: string - the name of the id field for this class or null if it does not exist

classDeclaration.getOwnProperty(name) ⇒ `Property`

Returns the field with a given name or null if it does not exist. The field must be directly owned by this class -- the super-type is not introspected.

Kind: instance method of ClassDeclaration
Returns: Property - the field definition or null if it does not exist

Param	Type	Description
name	`string`	the name of the field

classDeclaration.getOwnProperties() ⇒ `Array.<Property>`

Returns the fields directly defined by this class.

Kind: instance method of ClassDeclaration
Returns: Array.<Property> - the array of fields

classDeclaration.getSuperType() ⇒ `string`

Returns the FQN of the super type for this class or null if this class does not have a super type.

Kind: instance method of ClassDeclaration
Returns: string - the FQN name of the super type or null

classDeclaration.getSuperTypeDeclaration() ⇒ `ClassDeclaration`

Get the super type class declaration for this class.

Kind: instance method of ClassDeclaration
Returns: ClassDeclaration - the super type declaration, or null if there is no super type.

classDeclaration.getAssignableClassDeclarations() ⇒ `Array.<ClassDeclaration>`

Get the class declarations for all subclasses of this class, including this class.

Kind: instance method of ClassDeclaration
Returns: Array.<ClassDeclaration> - subclass declarations.

classDeclaration.getDirectSubclasses() ⇒ `Array.<ClassDeclaration>`

Get the class declarations for just the direct subclasses of this class, excluding this class.

Kind: instance method of ClassDeclaration
Returns: Array.<ClassDeclaration> - direct subclass declarations.

classDeclaration.getAllSuperTypeDeclarations() ⇒ `Array.<ClassDeclaration>`

Get all the super-type declarations for this type.

Kind: instance method of ClassDeclaration
Returns: Array.<ClassDeclaration> - super-type declarations.

classDeclaration.getProperty(name) ⇒ `Property`

Returns the property with a given name or null if it does not exist. Fields defined in super-types are also introspected.

Kind: instance method of ClassDeclaration
Returns: Property - the field, or null if it does not exist

Param	Type	Description
name	`string`	the name of the field

classDeclaration.getProperties() ⇒ `Array.<Property>`

Returns the properties defined in this class and all super classes.

Kind: instance method of ClassDeclaration
Returns: Array.<Property> - the array of fields

classDeclaration.getNestedProperty(propertyPath) ⇒ `Property`

Get a nested property using a dotted property path

Kind: instance method of ClassDeclaration
Returns: Property - the property
Throws:

IllegalModelException if the property path is invalid or the property does not exist

Param	Type	Description
propertyPath	`string`	The property name or name with nested structure e.g a.b.c

classDeclaration.toString() ⇒ `String`

Returns the string representation of this class

Kind: instance method of ClassDeclaration
Returns: String - the string representation of the class