It would be nice to have a search, to use name anchors, sorting, prioritizing, etc.

Desciption

DomainFile is an entity which may have its data to the token and therefore be removed as sourc file i.e. it will still exist as an ubiquitous language's concept (the YAML file for DomainFile is not removed)

How does it would enhance hubi?

1. One source file less to worry about
2. Removes a "useless" indirection

Values could be limited to a certain amount of enumerated values

Keep in mind that in some languages, those values are like tokens themselves, while in others they are just like strings

And that some languages associate their "keys" to specific numbers in an orderly manner and others allow you to freely associate values

It is possible to make flags using enums

Some configurations require centralizing files into a single folder but others may want to allow a better control where to save files.

For instance, I personally would like to output some source files in the same folder as their domain file.

Allow a file where users may tweak how hubi behaves in order to attend their needs.

There should be a clear layer separation between what's part of Hubi's domain and what is part of its use cases

What about using Yoman or alike to scaffold Translators?

Though we should learn better what a Translator really does

Migrate the current CLI to the correct layer (according to Clean Architecture)

In order to have more than one client, Hubi would benefit to have an adapter layer between the external world and its use cases

This could be React client where a server some documents are read in order to create the client's domain model

Some attributes may have their own configuration, for instance, strings can have min and max length but booleans cannot.

What about adding the ones you need the most?

Mark a token as extending another, so users don't have to repeat themselves.

This differs from Inhiritance because this one may allow a translator to "only" copy-and-past attributes around while other ones may benefit of explicitly marking their source files as using an interface.

The first library Translator will allow who uses joi to create ubiquitous source files.

Any

• any.allow(value)
• any.valid(value) - aliases: only, equal
• any.invalid(value) - aliases: disallow, not
• any.required() - aliases: exist
• any.optional()
• any.forbidden()
• any.strip()
• any.description(desc)
• any.notes(notes)
• any.tags(tags)
• any.meta(meta)
• any.example(value)
• any.unit(name)
• any.options(options)
• any.strict(isStrict)
• any.default([value, [description]])
• any.concat(schema)
• any.when(condition, options)
• any.label(name)
• any.raw(isRaw)
• any.empty(schema)
• any.error(err)

Array

• array.sparse([enabled])
• array.single([enabled])
• array.items(type)
• array.ordered(type)
• array.min(limit)
• array.max(limit)
• array.length(limit)
• array.unique([comparator])

Boolean

• boolean.truthy(value)
• boolean.falsy(value)
• boolean.insensitive([enabled])

Binay

• binary.encoding(encoding)
• binary.min(limit)
• binary.max(limit)
• binary.length(limit)

Date

• date.min(date)
• date.max(date)
• date.iso()
• date.timestamp([type])

Func

• func.arity(n)
• func.minArity(n)
• func.maxArity(n)
• func.class()
• func.ref()

Number

• number.min(limit)
• number.max(limit)
• number.greater(limit)
• number.less(limit)
• number.integer()
• number.precision(limit)
• number.multiple(base)
• number.positive()
• number.negative()

Object

• object.keys([schema])
• Joi.object([schema]) notation
• Joi.object().keys([schema]) notation
• object.min(limit)
• object.max(limit)
• object.length(limit)
• object.pattern(regex, schema)
• object.and(peers)
• object.nand(peers)
• object.or(peers)
• object.xor(peers)
• object.with(key, peers)
• object.without(key, peers)
• object.rename(from, to, [options])
• object.assert(ref, schema, [message])
• object.unknown([allow])
• object.type(constructor, [name])
• object.schema()
• object.requiredKeys(children)
• object.optionalKeys(children)
• object.forbiddenKeys(children)

String

• string.insensitive()
• string.min(limit, [encoding])
• string.max(limit, [encoding])
• string.truncate([enabled])
• string.creditCard()
• string.length(limit, [encoding])
• string.regex(pattern, [name | options])
• string.replace(pattern, replacement)
• string.alphanum()
• string.token()
• string.email([options])
• string.ip([options])
• string.uri([options])
• string.guid() - aliases: uuid
• string.hex()
• string.base64([options])
• string.hostname()
• string.normalize([form])
• string.lowercase()
• string.uppercase()
• string.trim()
• string.isoDate()

Alternatives

• alternatives.try(schemas)
• alternatives.when(condition, options)

Lazy

• lazy(fn) - inherits from Any

Allow scanning a source file in order to output a domain file

Allows users to create fixture factories easily using Rosie.

Add a watch flag to rerun hubi on file changes

How does it would enhance hubi?

Users do not need to pollute their packages with a watcher solution

The domain file guide states the following about decorators

Each attribute type may have some decorators associated with it, enhancing how they are translated.

But the only decorator in place is range, because decorators were a late concept.

This issue aims to include of, return, arguments and any other that may appear, as decorators.

For that, decorators should be considerated part of the domain language.

Use hubi to generate hubi

How does it would enhance hubi?

It is the best proof of concept ever

Having default values exported would allow other code to reference them, making easy to not repeat writing code

Joi uses the same type of number for both integer and floats, but hubi is generating two

Environment

All

How to reproduce

Create a domain file of type integer or type float

Expectations

Expected Behaviour

It was supposed to yield Joi.number() flagged with "integer" when appropriated

Actual Behaviour

Generates Joi.integer() and Joi.float() when both do not exist

In order to speed things up, implement a mechanism to cache domain files

With a simple validation as a decorator for attribute, it is possible to be sure of consistent values across the different domains using Hubi

Allow functions to be used as attributes.

Allow hubi to use Translators which are not in this same repository.

Mark a token as inheriting from another, so users don't have to repeat themselves.

This differs from Interface || Extension because some translators may benefit from having it explicitly.

Some tokens have aliases

Some people may prefer to use JSON as domain files to configure their ubiquitous language

Configuring Sequelize models is a nice MVP, but being able to generate migrations would be awesome

Preferentially something users can interact with

Allow hubi to use decorators (from #106) which are not in this same repository.

For instance, configuring a required string to have a max length of 30 digits in a lot of domain files is boring, so allowing users to create a AlphanumericWithFixedLengthTo30 just for that project would avoid a lot of repeatition.

Useful link: nodejs.org/en/blog/npm/peer-dependencies

Allow injecting its own pug, CSS and/or js

Allow hubi to use attribute types which are not in this same repository.

For instance, configuring a required string to have a max length of 30 digits in a lot of domain files is boring, so allowing users to create a AlphanumericWithFixedLengthTo30 just for that project would avoid a lot of repeatition.

Useful link: https://nodejs.org/en/blog/npm/peer-dependencies/

Some Translators allow to have multiple attribute types together and do something about it, for instance, having a field marked as required when another one field is provided.

A hubi context means that tokens and attributes may yield different generated source files.

There are 4 kinds of contextual changes I can think of: add, delete, change and referential.

Example

Givin a token User, I can think in the following contexts, which exist in different repositories of an App

Back-end

1. Domain model: Uses Joi Translator to yield user_id, user_name, user_name and user_registred_at attributes
2. Sequelize model: Uses Sequelize Translator to generate the same attributes as 1
3. GraphQL type: Uses GrapqQL Translator but renames the tokens attributes in order to not expose my internal database schema, by not using "user_" as a prefix and renaming the token to Custumer

Front-end

4. Domain model: Uses Joi Translator to yield the same attributes as 3 but also rename the token to Custumer
5. React component: Translates exactly as the previous point but using PropTypes Translator

Achievement Service

6. Domain model: Uses Joi Translator to yield user_id attribute, as it is all it needs to send achievements

Why this issue is important

At the moment a translator yields exactly what is described by a domain file.

At the moment only the HTML is generated, and it is ugly.

By adding a PropType Translator, people would React nicely.

Make an interactive hubi start (or init) which tries to help you installing translators for you

Desciption

It should be done after externalizing translators #25 as a complement to it. Or maybe as its first version.

How does it would enhance hubi?

Helps "lazy" people to find some translators and start projects

Sometimes we duplicate duplicate token's attributes.

Maybe give users an option about how to deal with duplication: do they consider it an error or a warning?

Being able to generate GraphQL types automatically seems fun!

Sometimes we duplicate tokens themselves - by repeating their names

Maybe give users an option about how to deal with duplication: do they consider it an error or a warning?

Non-provided attributes end up using a default value.

Mark attributes as deprecated in order to make people stop using them.

Diffs two git tags' domain files trying to suggest how things have changed.

Include generated translations on their files, instead of creating a file apart.

Desciption

Add a way to annotate over tokens and attributes

How does it would enhance hubi?

Currently, deprecation may be used to signalize something which is not a good fit for description.

Setting a string as non-required don't allow to use nulls as its value

Enviroment

• MacOS [email protected]
• [email protected]

How to reproduce

name: Foo
attributes:
  - name: optionalString
    required: false
    default: null

Expectations

Expected Behaviour

let success = false
try {
	Joi.attempt({ optionalString: null }, Foo.SCHEMA);
	success = true
} catch(e) {
}

assert.ok(success, 'optionalString should be possible to be set to null')

In the code above the assert.ok should not fail

Actual Behaviour

It fails with the message "[1] "optionalString" must be a string"

The first non-js Translator I could come up with (as it was my previous fluent language).

I thought about generating C# partial classes where hubi's half is the one with the getters/setters variables the class public allows people to poke with.

Arrays having arrays that have arrays filled with arrays should be okayish