Mung / Types
===

# Usage

At the heart of making a schema for a schemaless database such as MongoDB are types. They are the equivalent of the types in a traditional relational database model (INT, VARCHAR, etc.).

Since MongoDB works well with JavaScript syntax, you can use JavaScript primitive types to declare your fields types. Let's say your users collection are made of documents composed of a username and a password. Both are string and be declared in your app such as:

```js
class User extends Mung.Model {
  static schema () {
    return {
      username : String,
      password : String
    }
  }
}
```

This will ensure all your usernames and passwords will be strings.

On top of [JavaScript native types](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Grammar_and_types), we offer custom types to make your life easier. You can also create your own types. We also offer multi-type supports (see `types`).

## Note

You can view a complete summary of type acceptance by running the test `mocha --compilers js:babel/register test/convert.js test/validate.js` to see results for convert and validate.

# Supported types

- Number
- String
- Boolean
- Date
- Object
- Error
- Regexp
- Mung.Mixed
- Mung.Hex
- Mung.Binary
- Mung.Octal
- Mung.ObjectID
- Mung.Location

Note that these types can be declared inside an array or an object (see below). Note also that you can create your custom types.

# Conversion

All types will try to convert values to them. For example, a type set to `String` will convert the number `1` to the string `"1"`. You can disable this by setting convert to false:

```js
{
  field : {
    type : String,
    convert : false
  }
}
```

In this case, `1` will not be accepted because it is not a string.

# Number

Will accept any finite numbers (pure or converted).

```js
{
  field : Number
}
```

## Conversion

Note once again that we rely on JavaScript to convert. Numeric strings will be converted to numbers as expected. Alphanumeric strings will fail to convert to numbers. Converting arrays to finite numbers depend on JavaScript design patterns:

```js
[]; // will convert to 0
[5]; // will convert to 5
[1,2]; // will **not** convert arrays with more than 1 item

isFinite([]); // true
isFinite([1]); // true
isFinite([1, 2]); // false
```

Other specifications include:

- `null` converts to 0, undefined does not convert to a finite number

# String

```js
{
  field : String
}
```

# Boolean

```js
{
  field : Boolean
}
```