Starts Connection class

Author: raphaelfaria

lib/connection.js

@@ -0,0 +1,42 @@
+import SchemaBlueprint from './schema';
+import Model from './model';
+
+export default class Connection {
+  constructor(path) {
+    if (!path) {
+      throw new Error('Database requires a path');
+    }
+
+    const connectionInstance = this;
+
+    this.Schema = class Schema extends SchemaBlueprint {
+      constructor(obj) {
+        super(obj);
+      }
+    };
+
+    this.models = {};
+
+    this.Schema.prototype.db = connectionInstance;
+  }
+
+  model(name, schema) {
+    if (!name || typeof name !== 'string') {
+      throw new Error('Invalid name for model');
+    }
+
+    if (this.models[name]) {
+      return this.models[name];
+    }
+
+    let argSchema = schema;
+
+    if (argSchema.constructor !== this.Schema) {
+      argSchema = new this.Schema(argSchema);
+    }
+
+    this.models[name] = Model.compile(name, argSchema, this);
+
+    return this.models[name];
+  }
+}

test/connection.js

@@ -0,0 +1,62 @@
+import assert from 'assert';
+import Connection from '../lib/connection';
+import Schema from '../lib/schema';
+import Model from '../lib/model';
+
+describe('Connection', () => {
+  describe('constructor', () => {
+    it('should succeed', () => {
+      assert.ok(new Connection('data'));
+    });
+
+    it('should fail', () => {
+      assert.throws(() => new Connection(), Error);
+    });
+
+    it('should create its own db schema type', () => {
+      const db = new Connection('data');
+      assert.ok(Schema.isPrototypeOf(db.Schema));
+    });
+  });
+
+  describe('model method', () => {
+    let db;
+
+    beforeEach(() => {
+      db = new Connection('data');
+    });
+
+    it('should create and store a model', () => {
+      const schema = new db.Schema({ field: String });
+      const model = db.model('TheModel', schema);
+
+      assert.ok(model);
+      assert.equal(model, db.models.TheModel);
+    });
+
+    it('should create a schema if an object is passed', () => {
+      const model = db.model('TheModel', { field: String });
+
+      assert.ok(model);
+      assert.ok(model.schema);
+      assert.ok(model.schema instanceof db.Schema);
+    });
+
+    it('should return an already registered model', () => {
+      const modelOne = db.model('TheModel', { field: String });
+      const modelTwo = db.model('TheModel', { field: String });
+
+      assert.equal(modelOne, modelTwo);
+    });
+
+    it('should fail because name is invalid', () => {
+      assert.throws(() => {
+        db.model('', { field: String });
+      }, Error, 'Invalid name for model');
+
+      assert.throws(() => {
+        db.model(123, { field: String });
+      }, Error, 'Invalid name for model');
+    });
+  });
+});