import { Container } from 'nomatic-data';
import ArangoDBAdapter from 'nomatic-arangodb-adapter';
 
const adapter = new ArangoDBAdapter({
    name: 'my-database',
    host: '127.0.0.1',
    port: 8579,
    password: 'somethingMoreSecureThanThis'
});
 
const store = new Container({
    adapter: adapter,
    
    /**
     * A few hooks are provided for your convenience, including:
     * - beforeGet
     * - afterGet
     * - beforeInsert
     * - afterInsert
     * - beforeUpdate
     * - afterUpdate
     * - beforeValidate
     * - afterValidate
     */ 
    beforeInsert(mapper, record) {
        record.createdAt = new Date();
    },
    beforeUpdate(mapper, record) {
        record.updatedAt = new Date();
    },
    
    /**
     * Here, we define the schema of all of our mappers. Other options
     * for each mapper can also be set here. Schema validation is provided
     * by [ajv](https://github.com/epoberezkin/ajv).
     */
    mappers: {
        people: {
            properties: {
                /**
                 * Implicit properties, such as `id` and `rev`, need not be 
                 * defined here. 
                 */ 
                firstName: {
                    type: 'string'
                },
                lastName: {
                    type: 'string'
                },
                emailAddress: {
                    type: 'string',
                    format: 'email'
                }
            },
            required: ['firstName', 'lastName'],
            /**
             * By default, additional properties are allowed in the record.
             */
            additionalProperties: false
        },
        accounts: {
            properties: {
                people: {
                    type: 'array',
                    items: {
                        type: 'string',
                        /**
                         * The 'mapper' keyword enforces relational integrity. Each item
                         * in this array matches an `id` of a record in the collection
                         * managed by the 'people' mapper.
                         */ 
                        mapper: 'people'
                    },
                    default: []
                }
            }
        }
    }
});
 
/**
 * The `load()` method will establish a connection with the database server, 
 * ensure that the database exists (or it will try and create it), and 
 * ensure all collection exists (or will create them).
 */
store.load().then(() => {
    return store.insertAll('people', [
        { firstName: 'John', lastName: 'Doe' },
        { firstName: 'Jane', lastName: 'Doe' }
    ]);
}).then(() => {
    /**
     * This is one way you can query for documents.
     */
    store.find('people')
        .where('lastName')
        .eq('Doe')
        .sort('firstName', 1)
        .limit(2)
        .skip(1)
        .run().then((results) => {
        //...
    });
    
    /**
     * You can also query much like how MongoDB query filters. The supported operators are:
     *  - $and
     *      Syntax: { $where: { $and: [ <expression>, ..., <expression> }, ... }
     *  - $or
     *      Syntax: { $where: { $or: [ <expression>, ..., <expression> }, ... }
     *  - $eq (expression)
     *      Syntax: { <property>: { $eq: { <value> } }
     *  - $ne (expression)
     *      Syntax: { <property>: { $ne: { <value> } }
     *  - $gt (expression)
     *      Syntax: { <property>: { $gt: { <value> } }
     *  - $gte (expression)
     *      Syntax: { <property>: { $gte: { <value> } }
     *  - $lt (expression)
     *      Syntax: { <property>: { $lt: { <value> } }
     *  - $lte (expression)
     *      Syntax: { <property>: { $lte: { <value> } }
     *  - $in (expression)
     *      Syntax: { <property>: { $in: [ <value>, ..., <value> ] }
     *  - $nin (expression)
     *      Syntax: { <property>: { $nin: [ <value>, ..., <value> ] }
     *  - $exists (expression)
     *      Syntax: { <property>: { $exists: <true | false> } }
     * 
     * An expression always follows this form: 
     *  { <property>: { <operator>: <value> | [ <value>, ..., <value>] }
     *  
     * All the operators above can only be used in a $where object. 
     */
    store.findAll('people', {
        $where: {
            firstName: 'Jane'
        },
        $sort: [
            ['firstName', 1]
        ],
        $limit: 2,
        $skip: 1
    }).then((results) => {
        //...
    });
});