expressa 2.0.18 → 2.0.19

package/db/memory.js

@@ -1,79 +1,79 @@
-/* eslint no-unused-vars: ["error", { "args": "none" }] */
-const util = require('../util')
-
-module.exports = function (settings, collection) {
-  const store = {}
-
-  return {
-    type: 'memory',
-    init: async function () {},
-    all: async function () {
-      return this.find({})
-    },
-    find: async function (query, offset, limit, orderby, fields) {
-      const arr = Object.values(store)
-      let matches = util.mongoSearch(arr, query)
-      if (orderby) {
-        matches = util.orderBy(matches, orderby)
-      }
-      if (typeof offset !== 'undefined' && typeof limit !== 'undefined') {
-        matches = matches.slice(offset, offset + limit)
-      } else if (typeof offset !== 'undefined') {
-        matches = matches.slice(offset)
-      } else if (typeof limit !== 'undefined') {
-        matches = matches.slice(0, limit)
-      }
-      if (fields) {
-        matches = matches.map((doc) => util.mongoProject(doc, fields))
-      }
-      return matches
-    },
-    count: async function(...params) {
-      return (await this.find(...params)).length
-    },
-    get: async function (id, fields) {
-      if (!store[id]) {
-        throw new util.ApiError(404, 'document not found')
-      }
-      let doc = util.clone(store[id])
-      if (fields) {
-        doc = util.mongoProject(doc, fields)
-      }
-      return doc
-    },
-    create: async function (data) {
-      util.addIdIfMissing(data)
-      const id = data._id
-      if (store[id]) {
-        throw new util.ApiError(409, 'document already exists')
-      }
-      store[id] = data
-      return id
-    },
-    update: async function (id, data) {
-      data._id = data._id || id
-      store[id] = data
-      return data
-    },
-    // Designed to match Mongo
-    // https://docs.mongodb.com/manual/reference/method/db.collection.updateMany/
-    updateWithQuery: async function (query, update, options) {
-      const arr = Object.keys(store).map((id) => ({ _id: id, ...store[id]}) )
-      const matches = util.mongoSearch(arr, query)
-      matches.forEach((doc) => {
-        util.mongoUpdate(doc, update)
-        store[doc._id] = doc
-      })
-      return {
-        matchedCount: matches.length
-      }
-    },
-    delete: async function (id) {
-      if (store[id]) {
-        delete store[id]
-      } else {
-        throw new util.ApiError(404, 'document not found')
-      }
-    }
-  }
-}
+/* eslint no-unused-vars: ["error", { "args": "none" }] */
+const util = require('../util')
+
+module.exports = function (settings, collection) {
+  const store = {}
+
+  return {
+    type: 'memory',
+    init: async function () {},
+    all: async function () {
+      return this.find({})
+    },
+    find: async function (query, offset, limit, orderby, fields) {
+      const arr = Object.values(store)
+      let matches = util.mongoSearch(arr, query)
+      if (orderby) {
+        matches = util.orderBy(matches, orderby)
+      }
+      if (typeof offset !== 'undefined' && typeof limit !== 'undefined') {
+        matches = matches.slice(offset, offset + limit)
+      } else if (typeof offset !== 'undefined') {
+        matches = matches.slice(offset)
+      } else if (typeof limit !== 'undefined') {
+        matches = matches.slice(0, limit)
+      }
+      if (fields) {
+        matches = matches.map((doc) => util.mongoProject(doc, fields))
+      }
+      return matches
+    },
+    count: async function(...params) {
+      return (await this.find(...params)).length
+    },
+    get: async function (id, fields) {
+      if (!store[id]) {
+        throw new util.ApiError(404, 'document not found')
+      }
+      let doc = util.clone(store[id])
+      if (fields) {
+        doc = util.mongoProject(doc, fields)
+      }
+      return doc
+    },
+    create: async function (data) {
+      util.addIdIfMissing(data)
+      const id = data._id
+      if (store[id]) {
+        throw new util.ApiError(409, 'document already exists')
+      }
+      store[id] = data
+      return id
+    },
+    update: async function (id, data) {
+      data._id = data._id || id
+      store[id] = data
+      return data
+    },
+    // Designed to match Mongo
+    // https://docs.mongodb.com/manual/reference/method/db.collection.updateMany/
+    updateWithQuery: async function (query, update, options) {
+      const arr = Object.keys(store).map((id) => ({ _id: id, ...store[id]}) )
+      const matches = util.mongoSearch(arr, query)
+      matches.forEach((doc) => {
+        util.mongoUpdate(doc, update)
+        store[doc._id] = doc
+      })
+      return {
+        matchedCount: matches.length
+      }
+    },
+    delete: async function (id) {
+      if (store[id]) {
+        delete store[id]
+      } else {
+        throw new util.ApiError(404, 'document not found')
+      }
+    }
+  }
+}

package/db/mongo.js

@@ -1,86 +1,86 @@
-const mongo = require('mongodb')
-const MongoClient = mongo.MongoClient
-const util = require('../util')
-
-module.exports = function (settings, collection) {
-  return {
-    getClient: async function () {
-      const client = await MongoClient.connect(settings.mongodb_uri, { useNewUrlParser: true })
-      const db = client.db(settings.mongodb_uri.split('/')[3])
-      return db
-    },
-    init: function () {
-      if (!settings.mongodb_uri) {
-        console.error('{collection} uses mongo, but mongodb_url is undefined.')
-      }
-    },
-    all: async function () {
-      return this.find({})
-    },
-    find: async function (query, skip, limit, orderby, fields) {
-      const db = await this.getClient()
-      const cursor = db.collection(collection).find(query, { skip, limit, projection: fields, sort: orderby })
-      const docs = await cursor.toArray()
-      docs.forEach((doc) => {
-        if (doc._id) {
-          doc._id = doc._id.toString()
-        }
-      })
-      return docs
-    },
-    count: async function(query, skip, limit) {
-      const db = await this.getClient()
-      const count = await db.collection(collection).count(query, { skip, limit })
-      return count
-    },
-    get: async function (id, fields) {
-      const db = await this.getClient()
-      const doc = await db.collection(collection).findOne({ _id: id }, { projection: fields })
-      if (doc) {
-        doc._id = doc._id.toString()
-      }
-      if (!doc) {
-        throw new util.ApiError(404, 'document not found')
-      }
-      return doc
-    },
-    create: async function (data) {
-      util.addIdIfMissing(data)
-
-      const db = await this.getClient()
-      try {
-        const doc = await db.collection(collection).insertOne(data)
-        return doc.insertedId.toString()
-      } catch (err) {
-        if (err && err.message && err.message.includes('duplicate key error')) {
-          throw new util.ApiError(409, 'document already exists')
-        }
-      }
-    },
-    update: async function (id, data) {
-      data._id = id
-      const db = await this.getClient()
-      await db.collection(collection).replaceOne({
-        _id: id
-      }, data)
-      // doc._id = doc._id.toString()
-      return data
-    },
-    updateWithQuery: async function (query, update, options) {
-      const db = await this.getClient()
-      const res = await db.collection(collection).updateMany(query, update, options)
-      return {
-        matchedCount: res.matchedCount
-      }
-    },
-    delete: async function (id) {
-      const db = await this.getClient()
-      const res = await db.collection(collection).deleteOne({
-        _id: id
-      })
-      if (res.result.n !== 1) {
-        throw new util.ApiError(404, 'document not found')
-      }
-    }
-  }
-}
+const mongo = require('mongodb')
+const MongoClient = mongo.MongoClient
+const util = require('../util')
+
+module.exports = function (settings, collection) {
+  return {
+    getClient: async function () {
+      const client = await MongoClient.connect(settings.mongodb_uri, { useNewUrlParser: true })
+      const db = client.db(settings.mongodb_uri.split('/')[3])
+      return db
+    },
+    init: function () {
+      if (!settings.mongodb_uri) {
+        console.error('{collection} uses mongo, but mongodb_url is undefined.')
+      }
+    },
+    all: async function () {
+      return this.find({})
+    },
+    find: async function (query, skip, limit, orderby, fields) {
+      const db = await this.getClient()
+      const cursor = db.collection(collection).find(query, { skip, limit, projection: fields, sort: orderby })
+      const docs = await cursor.toArray()
+      docs.forEach((doc) => {
+        if (doc._id) {
+          doc._id = doc._id.toString()
+        }
+      })
+      return docs
+    },
+    count: async function(query, skip, limit) {
+      const db = await this.getClient()
+      const count = await db.collection(collection).count(query, { skip, limit })
+      return count
+    },
+    get: async function (id, fields) {
+      const db = await this.getClient()
+      const doc = await db.collection(collection).findOne({ _id: id }, { projection: fields })
+      if (doc) {
+        doc._id = doc._id.toString()
+      }
+      if (!doc) {
+        throw new util.ApiError(404, 'document not found')
+      }
+      return doc
+    },
+    create: async function (data) {
+      util.addIdIfMissing(data)
+
+      const db = await this.getClient()
+      try {
+        const doc = await db.collection(collection).insertOne(data)
+        return doc.insertedId.toString()
+      } catch (err) {
+        if (err && err.message && err.message.includes('duplicate key error')) {
+          throw new util.ApiError(409, 'document already exists')
+        }
+      }
+    },
+    update: async function (id, data) {
+      data._id = id
+      const db = await this.getClient()
+      await db.collection(collection).replaceOne({
+        _id: id
+      }, data)
+      // doc._id = doc._id.toString()
+      return data
+    },
+    updateWithQuery: async function (query, update, options) {
+      const db = await this.getClient()
+      const res = await db.collection(collection).updateMany(query, update, options)
+      return {
+        matchedCount: res.matchedCount
+      }
+    },
+    delete: async function (id) {
+      const db = await this.getClient()
+      const res = await db.collection(collection).deleteOne({
+        _id: id
+      })
+      if (res.result.n !== 1) {
+        throw new util.ApiError(404, 'document not found')
+      }
+    }
+  }
+}

package/db/postgres.js

@@ -1,93 +1,93 @@
-const util = require('../util')
-
-module.exports = function (settings, collectionId, collection) {
-  const pool = util.getPgPool(settings.postgresql_uri)
-
-  return {
-    init: async function () {
-      if (collection.plainStringIds) {
-        await pool.query('CREATE TABLE IF NOT EXISTS ' + collectionId + ' (id text primary key, data jsonb)')
-      } else {
-        await pool.query('CREATE TABLE IF NOT EXISTS ' + collectionId + ' (id uuid primary key, data jsonb)')
-      }
-    },
-    all: async function () {
-      return this.find({})
-    },
-    find: async function (rawQuery, offset, limit, orderby, fields) {
-      const pgSelect = util.mongoToPostgresSelect(collectionId, fields)
-      const pgWhere = util.mongoToPostgresWhere(collectionId, rawQuery)
-      let query = 'SELECT ' + pgSelect + ' FROM ' + collectionId + (pgWhere ? ' WHERE ' + pgWhere : '')
-      if (typeof orderby !== 'undefined') {
-        query += ' ORDER BY '
-        query += util.mongoToPostgresOrderBy(collectionId, orderby)
-      }
-      if (typeof offset !== 'undefined') {
-        query += ' OFFSET ' + offset
-      }
-      if (typeof limit !== 'undefined') {
-        query += ' LIMIT ' + limit
-      }
-      const result = await pool.query(query)
-      return result.rows.map((row) => row.data)
-    },
-    count: async function(rawQuery, offset, limit) {
-      const pgWhere = util.mongoToPostgresWhere(collectionId, rawQuery)
-      let query = 'SELECT COUNT(*) FROM ' + collectionId + (pgWhere ? ' WHERE ' + pgWhere : '')
-      if (typeof offset !== 'undefined') {
-        query += ' OFFSET ' + offset
-      }
-      if (typeof limit !== 'undefined') {
-        query += ' LIMIT ' + limit
-      }
-      const result = await pool.query(query)
-      return parseInt(result.rows[0].count)
-    },
-    get: async function (id, fields) {
-      const pgSelect = util.mongoToPostgresSelect(collectionId, fields)
-      const result = await pool.query(`SELECT ${pgSelect} FROM ${collectionId} WHERE id = $1`, [id])
-      if (result.rowCount === 0) {
-        throw new util.ApiError(404, 'document not found')
-      }
-      return result.rows[0].data
-    },
-    create: async function (data) {
-      util.addIdIfMissing(data)
-      try {
-        await pool.query('INSERT INTO ' + collectionId + ' (id, data) VALUES ($1, $2)', [data._id, data])
-      } catch (e) {
-        if (e.message.includes('duplicate key')) {
-          throw new util.ApiError(409, 'document already exists')
-        }
-        throw e
-      }
-      return data._id
-    },
-    update: async function (id, data) {
-      if (typeof data._id === 'undefined') {
-        data._id = id
-      }
-      const result = await pool.query('UPDATE ' + collectionId + ' SET data=$2,id=$3 WHERE id=$1', [id, data, data._id])
-      if (result.rowCount === 0) {
-        throw new util.ApiError(404, 'document not found')
-      }
-      return data
-    },
-    // eslint-disable-next-line no-unused-vars
-    updateWithQuery: async function (query, update, options) {
-      const pgWhere = util.mongoToPostgresWhere(collectionId, query)
-      const updateSql = util.mongoToPostgresUpdate(collectionId, update)
-      const result = await pool.query('UPDATE ' + collectionId + ' SET data=' + updateSql + ' WHERE ' + pgWhere)
-      return {
-        matchedCount: result.rowCount
-      }
-    },
-    delete: async function (id) {
-      const result = await pool.query('DELETE FROM ' + collectionId + ' WHERE id=$1', [id])
-      if (result.rowCount === 0) {
-        throw new util.ApiError(404, 'document not found')
-      }
-      return 'OK'
-    }
-  }
-}
+const util = require('../util')
+
+module.exports = function (settings, collectionId, collection) {
+  const pool = util.getPgPool(settings.postgresql_uri)
+
+  return {
+    init: async function () {
+      if (collection.plainStringIds) {
+        await pool.query('CREATE TABLE IF NOT EXISTS ' + collectionId + ' (id text primary key, data jsonb)')
+      } else {
+        await pool.query('CREATE TABLE IF NOT EXISTS ' + collectionId + ' (id uuid primary key, data jsonb)')
+      }
+    },
+    all: async function () {
+      return this.find({})
+    },
+    find: async function (rawQuery, offset, limit, orderby, fields) {
+      const pgSelect = util.mongoToPostgresSelect(collectionId, fields)
+      const pgWhere = util.mongoToPostgresWhere(collectionId, rawQuery)
+      let query = 'SELECT ' + pgSelect + ' FROM ' + collectionId + (pgWhere ? ' WHERE ' + pgWhere : '')
+      if (typeof orderby !== 'undefined') {
+        query += ' ORDER BY '
+        query += util.mongoToPostgresOrderBy(collectionId, orderby)
+      }
+      if (typeof offset !== 'undefined') {
+        query += ' OFFSET ' + offset
+      }
+      if (typeof limit !== 'undefined') {
+        query += ' LIMIT ' + limit
+      }
+      const result = await pool.query(query)
+      return result.rows.map((row) => row.data)
+    },
+    count: async function(rawQuery, offset, limit) {
+      const pgWhere = util.mongoToPostgresWhere(collectionId, rawQuery)
+      let query = 'SELECT COUNT(*) FROM ' + collectionId + (pgWhere ? ' WHERE ' + pgWhere : '')
+      if (typeof offset !== 'undefined') {
+        query += ' OFFSET ' + offset
+      }
+      if (typeof limit !== 'undefined') {
+        query += ' LIMIT ' + limit
+      }
+      const result = await pool.query(query)
+      return parseInt(result.rows[0].count)
+    },
+    get: async function (id, fields) {
+      const pgSelect = util.mongoToPostgresSelect(collectionId, fields)
+      const result = await pool.query(`SELECT ${pgSelect} FROM ${collectionId} WHERE id = $1`, [id])
+      if (result.rowCount === 0) {
+        throw new util.ApiError(404, 'document not found')
+      }
+      return result.rows[0].data
+    },
+    create: async function (data) {
+      util.addIdIfMissing(data)
+      try {
+        await pool.query('INSERT INTO ' + collectionId + ' (id, data) VALUES ($1, $2)', [data._id, data])
+      } catch (e) {
+        if (e.message.includes('duplicate key')) {
+          throw new util.ApiError(409, 'document already exists')
+        }
+        throw e
+      }
+      return data._id
+    },
+    update: async function (id, data) {
+      if (typeof data._id === 'undefined') {
+        data._id = id
+      }
+      const result = await pool.query('UPDATE ' + collectionId + ' SET data=$2,id=$3 WHERE id=$1', [id, data, data._id])
+      if (result.rowCount === 0) {
+        throw new util.ApiError(404, 'document not found')
+      }
+      return data
+    },
+    // eslint-disable-next-line no-unused-vars
+    updateWithQuery: async function (query, update, options) {
+      const pgWhere = util.mongoToPostgresWhere(collectionId, query)
+      const updateSql = util.mongoToPostgresUpdate(collectionId, update)
+      const result = await pool.query('UPDATE ' + collectionId + ' SET data=' + updateSql + ' WHERE ' + pgWhere)
+      return {
+        matchedCount: result.rowCount
+      }
+    },
+    delete: async function (id) {
+      const result = await pool.query('DELETE FROM ' + collectionId + ' WHERE id=$1', [id])
+      if (result.rowCount === 0) {
+        throw new util.ApiError(404, 'document not found')
+      }
+      return 'OK'
+    }
+  }
+}

package/doc/authentication.md

@@ -1,38 +1,38 @@
-## Authentication
-Uses [JSON Web Tokens](https://jwt.io/)
-
-| method | endpoint                      | description  |
-|--------|-------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| POST   | /users/login                  | expects JSON in the message body. e.g. `{"email": "email@example.com", password: "<the password>"}                                                                                             |
-
-Returns the following
-```javascript
-{
-  "uid": "a52ee085-ff47-4ee1-bac3-a8a319f674ed",
-  "token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJfaWQiOiI1NmNkNWM5NmY4MjA4N2I1MDQ0OTM3YjEiLCJ1bml2ZXJzaXR5IjoiQllVIiwiZnVsbE5hbWUiOiJUaG9tYXMgSGFuc2VuIiwicGFzc3dvcmQiOiIkMmEkMTAkb0prdlBnTTlkR2FJRTIzaWFabGEvT0tjZC9PL3phSGFJOHFRUDBuZ2pPUVV1Ums3Vng2QkciLCJlbWFpbCI6InRoNDAxOUBnbWFpbC5jb20iLCJfX3YiOjAsImxpc3RpbmdzIjpbXSwiaWF0IjoxNDU2NDMwMjE5LCJleHAiOjE0NTY1MTY2MTl9._ijngdgwLU9AJnAjbySUgEFsR8hJCSw8PhH1AnyBHuM"
-}
-```
-Or it will respond with a status code of 401 and a message explaining why they can't login.
-
-```javascript
-{
-  "success": false,
-  "message": "Authentication failed. Wrong password."
-}
-```
-
-The returned token must then be passed in as a header on future requests using the header x-access-token
-
-* `GET /users/me` - returns the logged in user's object
-
-## Making authenticated requests
-
-After obtaining a token as described above you need to pass it with your request in one of these ways
-
-1. Using the `x-access-token`
-
-	`curl --header "x-access-token: eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJfaWQiOiI1NmNkNWM5NmY4MjA4N2I1MDQ0OTM3YjEiLCJ1bml2ZXJzaXR5IjoiQllVIiwiZnVsbE5hbWUiOiJUaG9tYXMgSGFuc2VuIiwicGFzc3dvcmQiOiIkMmEkMTAkb0prdlBnTTlkR2FJRTIzaWFabGEvT0tjZC9PL3phSGFJOHFRUDBuZ2pPUVV1Ums3Vng2QkciLCJlbWFpbCI6InRoNDAxOUBnbWFpbC5jb20iLCJfX3YiOjAsImxpc3RpbmdzIjpbXSwiaWF0IjoxNDU2NDMwMjE5LCJleHAiOjE0NTY1MTY2MTl9._ijngdgwLU9AJnAjbySUgEFsR8hJCSw8PhH1AnyBHuM" api.example.com/users/me`
-
-2. Pass the token as a query parameter.
-
-	`curl api.example.com/users/me?token=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJfaWQiOiI1NmNkNWM5NmY4MjA4N2I1MDQ0OTM3YjEiLCJ1bml2ZXJzaXR5IjoiQllVIiwiZnVsbE5hbWUiOiJUaG9tYXMgSGFuc2VuIiwicGFzc3dvcmQiOiIkMmEkMTAkb0prdlBnTTlkR2FJRTIzaWFabGEvT0tjZC9PL3phSGFJOHFRUDBuZ2pPUVV1Ums3Vng2QkciLCJlbWFpbCI6InRoNDAxOUBnbWFpbC5jb20iLCJfX3YiOjAsImxpc3RpbmdzIjpbXSwiaWF0IjoxNDU2NDMwMjE5LCJleHAiOjE0NTY1MTY2MTl9._ijngdgwLU9AJnAjbySUgEFsR8hJCSw8PhH1AnyBHuM`
+## Authentication
+Uses [JSON Web Tokens](https://jwt.io/)
+
+| method | endpoint                      | description  |
+|--------|-------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| POST   | /users/login                  | expects JSON in the message body. e.g. `{"email": "email@example.com", password: "<the password>"}                                                                                             |
+
+Returns the following
+```javascript
+{
+  "uid": "a52ee085-ff47-4ee1-bac3-a8a319f674ed",
+  "token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJfaWQiOiI1NmNkNWM5NmY4MjA4N2I1MDQ0OTM3YjEiLCJ1bml2ZXJzaXR5IjoiQllVIiwiZnVsbE5hbWUiOiJUaG9tYXMgSGFuc2VuIiwicGFzc3dvcmQiOiIkMmEkMTAkb0prdlBnTTlkR2FJRTIzaWFabGEvT0tjZC9PL3phSGFJOHFRUDBuZ2pPUVV1Ums3Vng2QkciLCJlbWFpbCI6InRoNDAxOUBnbWFpbC5jb20iLCJfX3YiOjAsImxpc3RpbmdzIjpbXSwiaWF0IjoxNDU2NDMwMjE5LCJleHAiOjE0NTY1MTY2MTl9._ijngdgwLU9AJnAjbySUgEFsR8hJCSw8PhH1AnyBHuM"
+}
+```
+Or it will respond with a status code of 401 and a message explaining why they can't login.
+
+```javascript
+{
+  "success": false,
+  "message": "Authentication failed. Wrong password."
+}
+```
+
+The returned token must then be passed in as a header on future requests using the header x-access-token
+
+* `GET /users/me` - returns the logged in user's object
+
+## Making authenticated requests
+
+After obtaining a token as described above you need to pass it with your request in one of these ways
+
+1. Using the `x-access-token`
+
+	`curl --header "x-access-token: eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJfaWQiOiI1NmNkNWM5NmY4MjA4N2I1MDQ0OTM3YjEiLCJ1bml2ZXJzaXR5IjoiQllVIiwiZnVsbE5hbWUiOiJUaG9tYXMgSGFuc2VuIiwicGFzc3dvcmQiOiIkMmEkMTAkb0prdlBnTTlkR2FJRTIzaWFabGEvT0tjZC9PL3phSGFJOHFRUDBuZ2pPUVV1Ums3Vng2QkciLCJlbWFpbCI6InRoNDAxOUBnbWFpbC5jb20iLCJfX3YiOjAsImxpc3RpbmdzIjpbXSwiaWF0IjoxNDU2NDMwMjE5LCJleHAiOjE0NTY1MTY2MTl9._ijngdgwLU9AJnAjbySUgEFsR8hJCSw8PhH1AnyBHuM" api.example.com/users/me`
+
+2. Pass the token as a query parameter.
+
+	`curl api.example.com/users/me?token=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJfaWQiOiI1NmNkNWM5NmY4MjA4N2I1MDQ0OTM3YjEiLCJ1bml2ZXJzaXR5IjoiQllVIiwiZnVsbE5hbWUiOiJUaG9tYXMgSGFuc2VuIiwicGFzc3dvcmQiOiIkMmEkMTAkb0prdlBnTTlkR2FJRTIzaWFabGEvT0tjZC9PL3phSGFJOHFRUDBuZ2pPUVV1Ums3Vng2QkciLCJlbWFpbCI6InRoNDAxOUBnbWFpbC5jb20iLCJfX3YiOjAsImxpc3RpbmdzIjpbXSwiaWF0IjoxNDU2NDMwMjE5LCJleHAiOjE0NTY1MTY2MTl9._ijngdgwLU9AJnAjbySUgEFsR8hJCSw8PhH1AnyBHuM`

package/doc/automatic-fields.md

@@ -1,12 +1,12 @@
-## Automatic Fields
-
-Each object will contain this meta property which has autogenerated fields shared across all collection types:
-
-```javascript
-  "meta": {
-    "created": "2016-05-16T23:56:11.615Z",
-    "updated": "2016-05-16T23:56:28.262Z",
-    "owner": "56cb5df7f56ef0b92f7b984b"
-  },
-```
-
+## Automatic Fields
+
+Each object will contain this meta property which has autogenerated fields shared across all collection types:
+
+```javascript
+  "meta": {
+    "created": "2016-05-16T23:56:11.615Z",
+    "updated": "2016-05-16T23:56:28.262Z",
+    "owner": "56cb5df7f56ef0b92f7b984b"
+  },
+```
+

package/doc/blogexample.md

@@ -1,16 +1,16 @@
-## Blog Example
-
-### Creating the blog "post" collection and its schema.
-
-Here's what the UI looks like for adding this new custom collection type.
-
-![post schema 3](https://cloud.githubusercontent.com/assets/406149/15308189/c3612ade-1b97-11e6-8f87-faeee4aba8bd.png)
-
---------------------------------
-
-### Creating a post
-
-After creating the blog post collection, here's what adding a document of that type looks like using the built in editor.
-
-![create post 3](https://cloud.githubusercontent.com/assets/406149/15308188/c361368c-1b97-11e6-869a-ac40ba838dde.png)
-
+## Blog Example
+
+### Creating the blog "post" collection and its schema.
+
+Here's what the UI looks like for adding this new custom collection type.
+
+![post schema 3](https://cloud.githubusercontent.com/assets/406149/15308189/c3612ade-1b97-11e6-8f87-faeee4aba8bd.png)
+
+--------------------------------
+
+### Creating a post
+
+After creating the blog post collection, here's what adding a document of that type looks like using the built in editor.
+
+![create post 3](https://cloud.githubusercontent.com/assets/406149/15308188/c361368c-1b97-11e6-869a-ac40ba838dde.png)
+