• Single file per category
• Group categories into directories
• Hardcode types to lib/types.js

In master branch of globalstorage metaschema.domains is missing many domains after loading 'schemas/system', the only ones present are:

Map {
  'IdStatus' => Enum { values: [ 'Prealloc', 'Init', 'Actual', 'Historical' ] },
  'StorageKind' => Enum { values: [ 'Master', 'Cache', 'Backup', 'Replica' ] },
  'CategoryRealm' => Enum { values: [ 'Global', 'System', 'Local' ] },
  'CategoryFamily' => Enum {
    values:
     [ 'Registry',
       'Dictionary',
       'Table',
       'Log',
       'View',
       'History',
       'Memory' ] },
  'UserAccess' => Enum {
    values: [ 'Read', 'Insert', 'Update', 'Delete', 'Execute', 'Audit' ] },
  'AccessFlags' => Flags {
    values: [ 'Read', 'Insert', 'Update', 'Delete', 'Execute', 'Audit' ],
    enum: 'UserAccess' },
  'Compression' => Enum { values: [ 'None', 'GZIP', 'ZIP' ] },
  'SessionToken' => { type: 'string', length: 64 },
  'MediaType' => Enum {
    values:
     [ 'text/plain',
       'text/csv',
       'image/png',
       'image/gif',
       'image/jpeg',
       'image/svg+xml',
       'image/tiff',
       'application/pdf',
       'application/rtf',
       'application/zip',
       'application/json' ] },
  'SystemType' => Enum { values: [ 'Global', 'Autonomous', 'Standalone' ] },
  'ServerType' => Enum { values: [ 'Root', 'Server', 'Backup', 'Reserve' ] },
  'NodeType' => Enum { values: [ 'Master', 'Worker', 'Task' ] },
  'NodeStatus' => Enum { values: [ 'Init', 'Active', 'Pause', 'Restart', 'Hang' ] } }

Code to reproduce:

'use strict';
const metaschema = require('metaschema');
metaschema.load('schemas/system', (error, schema) => {
  if (error) {
    console.error(error);
    return;
  }

  console.log(metaschema.domains);
});

Deny relation from Global to Local.
Registry, Dictionary, System, Log, History decorated schemas must not have relations to Local

At the moment, some of the date-time related domains are described as numbers, for example:

Such domain schemas will lead to problems when validating the values provided to functions expecting date-time values since providing Date objects will not be allowed.

I propose to set the type field for these domains to 'object', and to add another field to the domain definition (that can be called instanceof, for example), that will require the values for such domains to be the Data objects.

• Enum should be treated as required: true
• Validate fields value to be Enum.values.includes(value)
• taxonomy/Domains.schema should be validated including Enum

If function have no description as of now will be parsed -1 arguments

• First pass: load, parse, put to collection
• Second pass: cross-link schemas

Category schemas have a different set of fields when loaded from schema files using metaschema.load() as opposed to using metaschema.build() method.

When using metaschema.build() method, the resulting category schema has three fields: name, definition, factory. It is being created in factorify function:

When using metaschema.load() to load the schema definitions from files, it produces schema objects which are similar to the ones we get in the definition field when using metaschema.build():

It leads to problems when using the schema definitions produced by metaschema.load() with other methods (such as metaschema.validate()) since the category schema object is expected to have these fields:

/cc @tshemsedinov

• method description
• argument description

Currently, we don't provide a way to define whether a number is an integer or not, also I would be also nice to define desired precision for the number.

I propose to add 2 Domain attributes: precision and floating.

Combine into code block

Example: method(arguments);
Result: { name: value }

Use typeof valiable instead of typeof(variable) except cases like this: typeof(5 + '')

Function createInstance in lib/schema.js can not create instances of domains which are value decorators, because we can not specify type field for them.

Here an identifier type is an own JS type of value, but expected is name(name of the category, we creating instance of), because value decorators Enum and Flags can not have property type. So type === expected is false and it returns null

We need plugin for IDE to validate declarative structure (JSON, JSON5, JSTP) or JavaScript and have autocomplete for fields and values defined in schemas. For the first time it will be ok to have such plugin just for single IDE.

Here we are getting category information from categories

And then trying to find out type of this category

But the problem is that destination argument in function verifyLink is an object from categories, which looks like { name, definition, factory }, so getCategoryType always defines its type as Local, even if it is not.

metaschema.build(schema) returns a factory, using which we are creating instances of category. So if there is a schema with Logical domain field and we trying to create an instance, where this field is set to false factory will recognize it as invalid value for this field.

value = createInstance(type, value); 
if (value !== null) obj[field] = value; 
else return null; 

We need possibility to document properties.

Current Enum form lib/schema.js implements enumerated type. We need it but enumerated type should be moved to common and we need different Enum in metaschema that will be just decorator for schema.

Now metaschema.categories contain records with schema.name === undefined that's domain definitions and metaschema files loaded and added to metaschema.categories by mistake

Please test validation on globalstorage. For example Action.Category references Category, but it is not Local, it is System. One System category can reference another System category. And we need readable output too.

Illegal reference to a 'Local' category 'Category' from Action.Category,Illegal reference to a 'Local' category 'Category' from Category.Master,Illegal reference to a 'Local' category 'Catalog' from Catalog.Parent,Illegal reference to a 'Local' category 'Category' from Identifier.Category,Illegal reference to a 'Local' category 'Language' from Localization.Language,Illegal reference to a 'Local' category 'Session' from Locking.Session,Illegal reference to a 'Local' category 'SystemUser' from Locking.SystemUser,Illegal reference to a 'Local' category 'SystemUser' from Log.SystemUser,Illegal reference to a 'Local' category 'Identifier' from Log.Identifier,Illegal reference to a 'Local' category 'Role' from Permission.Role,Illegal reference to a 'Local' category 'Category' from Permission.Category,Illegal reference to a 'Local' category 'Identifier' from Permission.Bound,Illegal reference to a 'Local' category 'Action' from Permission.Actions,Illegal reference to a 'Local' category 'System' from Replication.Source,Illegal reference to a 'Local' category 'System' from Replication.Destination,Illegal reference to a 'Local' category 'Category' from Replication.Category,Illegal reference to a 'Local' category 'Category' from Schema.Category,Illegal reference to a 'Local' category 'Subdivision' from Subdivision.Parent,Illegal reference to a 'Local' category 'Role' from SystemUser.Roles

• We need to defile categories which support history
• Only decorated categories can be included: Include(CategoryName)

Use Enum('value1', 'value2', ...) in schemas to build category enumerated type

This category decorator will limit entity relations to local server. Remote servers and entities stored there can't access and refer to this entities. Example: Session

Use Include({ category: 'categoryName' }) in schemas to include field set from one ca category to another

We need tests that will check that validation passes for valid schemas and generates valid errors otherwise.

• Domain.schema
• Category.schema

Multiple layers:

• Primitives: string, number, boolean, null, undefined, symbol, object, function, array
• Types: ip, int, float, bool, str, char, enum, date, time, timestamp, text, function
• Domains: Ip, Bool, Money, Passport, Nomen, Text, JSON, URL, Host, HTML, Year, Month, Day, Time, Date, DateTime, Interval, Length, Weight, Distance, Temperature, Energy, Area, Volume, Speed
• Structures: object, record, set, map, array
• Categories: Person, Organization, City, Country, Project, Vehicle, Asset, Building, Document, Address
  • With fields, for example: Person.Surname:Nomen, Person.Salary:Money, Person.Job:Organization

We need to validate objects before storing to database, validate keys and values, set default values.

Before .md generation we need introspection and inventory data structures.

Prepare more cases, problems in this approach and prepare specification.

Examples:

Function signature:

doSomething(
  par1: 'string',
  par2: ['string', 10],
  par3: ['number', [0, 99999], 'nullable']
)

Data definition

{
  par1: 'string',
  par2: ['string', 10],
  par3: ['number', [0, 99999], 'nullable']
}

@tshemsedinov I suggest that metaschema automatically create history categories for every category wrapped in History Decorator. WDYT?

metaschema.check(schemaName, data)

Rewrite tests https://github.com/metarhia/metaschema/tree/master/test using metatests(https://github.com/metarhia/metatests).

Now we have createInstance(category, instance / ...parts) where we pass instance (not validated data structure) or parts (values of fields according to Category schema). It is slow and obviously heavy. We need { valid: bool, errors: Array } = validate(category, instance) for lightweight validation.

This way it's not limiting an internal representation to actually using bitmasks to represent the data.
Also, if anyone has other suggestions for another name feel free to speak out, as I don't think Flags is good enough.
Other names may be

• BitFlags - I think just Flags is better and Bit prefix doesn't bring any value into it
• Set - good, but too broad, it may not be intuitive that you can actually use it as Flags.

/cc @tshemsedinov @nechaido @belochub

Dynamically build composite types (with JavaScript prototypes, closures or classes) from metadata

Schema decorator to wrap Bitmask data type (like Enum).
Refs: metarhia/common#175

Use List('categoryName') in schemas to build category list