mevn-orm 2.3.5 → 2.3.6

package/dist/connection.d.ts

@@ -0,0 +1,2 @@
+declare const connection: import("knex").Knex<any, unknown[]>;
+export default connection;

package/dist/connection.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const import_cwd_1 = tslib_1.__importDefault(require("import-cwd"));
+const config = import_cwd_1.default('./knexfile');
+const knex_1 = tslib_1.__importDefault(require("knex"));
+//@ts-ignore
+const connection = knex_1.default(process.env.NODE_ENV === 'testing' ? config.development : config.production);
+exports.default = connection;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import Model from './model';
+declare const _default: {
+    Model: typeof Model;
+    DB: import("knex").Knex<any, unknown[]>;
+};
+export = _default;

package/dist/index.js

@@ -0,0 +1,9 @@
+"use strict";
+const tslib_1 = require("tslib");
+const dotenv_1 = tslib_1.__importDefault(require("dotenv"));
+dotenv_1.default.config();
+const model_1 = tslib_1.__importDefault(require("./model"));
+const connection_1 = tslib_1.__importDefault(require("./connection"));
+module.exports = {
+    Model: model_1.default, DB: connection_1.default
+};

package/dist/model.d.ts

@@ -0,0 +1,171 @@
+declare class Model {
+    #private;
+    collection: {};
+    /**
+     * These columns are hidden in collections
+     */
+    hidden: any[];
+    /**
+     * Model ID
+     */
+    id: number;
+    /**
+     * Model name
+     */
+    modelName: string;
+    /**
+     * The current table
+     */
+    table: any;
+    /**
+     * The foreign key
+     */
+    foreignKey: string;
+    /**
+     * Contains the db record
+     */
+    currentModel: any;
+    static collection: any;
+    static currentStaticQuery: any;
+    /**
+     * New Model instance
+     * @param id the database ID of the model
+     */
+    constructor(id: number, attributes?: {
+        [x: string]: any;
+    });
+    /**
+     * Fetch the current model from the database
+     */
+    fetch(): Promise<any>;
+    /**
+     * Delete the current model
+     * @returns {Promise} deletes item from the database
+     */
+    destroy(): Promise<any>;
+    /**
+     * Update a given model
+     * @param {Array} attributes fields
+     * @returns {Promise|any} updates a model in the database
+     */
+    update(attributes?: Array<any>): Promise<any>;
+    /**
+     * Return an array rep of a model
+     */
+    toArray(): any;
+    /**
+     * ========================================================================
+     *      STATIC METHODS
+     * ========================================================================
+     */
+    /**
+     * Create a collection to return to the user
+     * @param { String| Array } elements
+     * @returns Array()
+     */
+    private static collect;
+    /**
+     * The models table name
+     * eg Movie will automatically be movies
+     * @returns String
+     */
+    static tableName(): any;
+    /**
+     * Return the models that match a given condition
+     * @param columns The columns to return
+     * @returns
+     */
+    static get(columns?: string): Promise<Model | Model[]>;
+    /**
+     * Get the Model count
+     */
+    static count(): Promise<{
+        [k: string]: string | number;
+    }[]>;
+    /**
+     * Get all rows from the database
+     *
+     * @returns Promise<>
+     */
+    static all(): Promise<Model[]>;
+    /**
+     * Get rows that match some conditions
+     * @param {Object} conditions
+     */
+    static where(conditions?: object): typeof Model;
+    /**
+     * Get rows that match some conditions
+     * @param {Object} conditions
+     */
+    static whereFirst(conditions?: object): Promise<any>;
+    /**
+     * Get the first record for the database
+     *
+     * @returns Promise
+     */
+    static first(): Promise<Model>;
+    /**
+     * Find model by Id
+     * @param id
+     */
+    static find(id: number): Promise<Model>;
+    /**
+     * Delete a model from the database
+     * @param id
+     */
+    static delete(id: number): Promise<number>;
+    /**
+     * Create a new Model
+     * @param attributes
+     */
+    static create(attributes?: any[]): Promise<Model>;
+    /**
+     * -----------------------------------------------
+     *               Relationships
+     * -----------------------------------------------
+     */
+    /**
+     * Relationships to load this the current model
+     * @param {Array} relations
+     */
+    load(relations?: Array<any>): this;
+    /**
+     * Define a HasOne relationship
+     * @param {String} related
+     * @param {String} primaryKey
+     * @param {String} foreignKey
+     */
+    hasOne(related: string, primaryKey?: number | any, foreignKey?: number | any): Promise<any>;
+    /**
+     * Define a reverse has one relationship
+     * @param {String} related
+     * @param {String} primaryKey
+     * @param {String} foreignKey
+     */
+    belongsTo(related: string, primaryKey?: string, foreignKey?: string): Promise<any[]>;
+    /**
+     * Define a Many to many relationship relationship
+     * @param {String} related
+     */
+    belongsToMany(related: string, primaryKey?: string, foreignKey?: string): string;
+    /**
+         * Define a HasMany relationship
+         * @param {String} related
+         * @param {String} primaryKey
+         * @param {String} foreignKey
+         */
+    hasMany(related: string, primaryKey?: string, foreignKey?: string): Promise<any[]>;
+    /**
+     * MorphOne relationship
+     * @param {String} related the class name of the other model
+     * @param {String} reference the reference column in the other model
+     */
+    morphOne(related: String, reference: String): Promise<any>;
+    /**
+     * MorphMany relationship
+     * @param {String} related the class name of the other model
+     * @param {String} reference the reference column in the other model
+     */
+    morphMany(related: String, reference: String): Promise<any[]>;
+}
+export default Model;

package/dist/model.js

@@ -0,0 +1,399 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const connection_1 = tslib_1.__importDefault(require("./connection"));
+const pluralize_1 = tslib_1.__importDefault(require("pluralize"));
+class Model {
+    /**
+     * New Model instance
+     * @param id the database ID of the model
+     */
+    constructor(id, attributes = {}) {
+        this.#collection = {};
+        this.#hidden = [];
+        this.id = id;
+        this.#modelName = this.constructor.name.toLowerCase();
+        this.#table = pluralize_1.default(this.#modelName);
+        this.#foreignKey = `${this.#modelName}_id`;
+        if (attributes) {
+            for (const a in attributes) {
+                if (Object.prototype.hasOwnProperty.call(attributes, a)) {
+                    this[a] = attributes[a];
+                }
+            }
+        }
+        this.fetch().then((c) => {
+            this.#currentModel = c;
+            for (const a in c) {
+                this[a] = c[a];
+            }
+        });
+    }
+    #foreignKey;
+    #collection;
+    #hidden;
+    #modelName;
+    #currentModel;
+    #table;
+    /**
+     * Fetch the current model from the database
+     */
+    async fetch() {
+        try {
+            return connection_1.default
+                .table(this.#table)
+                .where('id', this.id)
+                .first();
+        }
+        catch (error) {
+            throw new Error(error).stack;
+        }
+    }
+    /**
+     * Delete the current model
+     * @returns {Promise} deletes item from the database
+     */
+    async destroy() {
+        try {
+            await connection_1.default
+                .table(this.#table)
+                .where({ id: this.id })
+                .delete();
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    /**
+     * Update a given model
+     * @param {Array} attributes fields
+     * @returns {Promise|any} updates a model in the database
+     */
+    async update(attributes = []) {
+        try {
+            await connection_1.default
+                .table(this.#table)
+                .where({ id: this.id })
+                .update(attributes);
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    /**
+     * Return an array rep of a model
+     */
+    toArray() {
+        return this.#currentModel;
+    }
+    /**
+     * ========================================================================
+     *      STATIC METHODS
+     * ========================================================================
+     */
+    /**
+     * Create a collection to return to the user
+     * @param { String| Array } elements
+     * @returns Array()
+     */
+    static collect(elements = '') {
+        console.log(this.collection);
+        this.collection.push(elements);
+    }
+    /**
+     * The models table name
+     * eg Movie will automatically be movies
+     * @returns String
+     */
+    static tableName() {
+        return pluralize_1.default(this.name).toLowerCase();
+    }
+    /**
+     * Return the models that match a given condition
+     * @param columns The columns to return
+     * @returns
+     */
+    static async get(columns = '*') {
+        const m = await this.currentStaticQuery.select(columns);
+        if (Array.isArray(m)) {
+            return m.map((model) => {
+                return new this(model.id, model);
+            });
+        }
+        return new this(m.id, m);
+    }
+    /**
+     * Get the Model count
+     */
+    static async count() {
+        try {
+            return await connection_1.default
+                .table(this.tableName())
+                .count();
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    /**
+     * Get all rows from the database
+     *
+     * @returns Promise<>
+     */
+    static async all() {
+        try {
+            const models = await connection_1.default.table(this.tableName()).select('*');
+            return models.map((m) => {
+                return new this(m.id, m);
+            });
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    /**
+     * Get rows that match some conditions
+     * @param {Object} conditions
+     */
+    static where(conditions = {}) {
+        try {
+            this.currentStaticQuery = connection_1.default
+                .table(this.tableName())
+                .where(conditions)
+                .select('*');
+            return this;
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    /**
+     * Get rows that match some conditions
+     * @param {Object} conditions
+     */
+    static async whereFirst(conditions = {}) {
+        try {
+            console.warn('where.first() has been deprecated and will be removed in future please use where().first() instead');
+            return await connection_1.default
+                .table(this.tableName())
+                .where(conditions)
+                .first();
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    /**
+     * Get the first record for the database
+     *
+     * @returns Promise
+     */
+    static async first() {
+        try {
+            if (this.currentStaticQuery) {
+                // It means it is chained
+                const model = await this.currentStaticQuery.first();
+                if (model) {
+                    return new this(model.id, model);
+                }
+                return null;
+            }
+            // It is not being chained
+            const record = await connection_1.default
+                .table(this.tableName())
+                .select('*')
+                .first();
+            return new this(record.id, record);
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    /**
+     * Find model by Id
+     * @param id
+     */
+    static async find(id) {
+        try {
+            const m = await connection_1.default
+                .table(this.tableName())
+                .where({ id })
+                .first();
+            if (m) {
+                return new this(id, m);
+            }
+            return null;
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    /**
+     * Delete a model from the database
+     * @param id
+     */
+    static async delete(id) {
+        try {
+            return await connection_1.default
+                .table(this.tableName())
+                .where({ id })
+                .del();
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    /**
+     * Create a new Model
+     * @param attributes
+     */
+    static async create(attributes = []) {
+        try {
+            const ids = await connection_1.default
+                .table(this.tableName())
+                .insert(attributes);
+            const m = new this(ids[0]);
+            await m.fetch();
+            return m;
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    /**
+     * -----------------------------------------------
+     *               Relationships
+     * -----------------------------------------------
+     */
+    /**
+     * Relationships to load this the current model
+     * @param {Array} relations
+     */
+    load(relations = []) {
+        this.#collection[this.#modelName] = this.#currentModel;
+        relations.forEach(function (relation) {
+            const rows = this[relation]();
+            this.#collection[this.#modelName][relation] = rows;
+        }, this);
+        return this;
+    }
+    /**
+     * Define a HasOne relationship
+     * @param {String} related
+     * @param {String} primaryKey
+     * @param {String} foreignKey
+     */
+    async hasOne(related, primaryKey = null, foreignKey = null) {
+        // I should get a query to get related records
+        const fk = foreignKey || this.#foreignKey;
+        const pk = primaryKey || this.id;
+        return await connection_1.default
+            .table(pluralize_1.default(related.toLowerCase()))
+            // in the form of model_id
+            .where(fk, pk)
+            .first()
+            .asCallback((err, rows) => {
+            if (err) {
+                throw err;
+            }
+            return rows;
+        });
+    }
+    /**
+     * Define a reverse has one relationship
+     * @param {String} related
+     * @param {String} primaryKey
+     * @param {String} foreignKey
+     */
+    async belongsTo(related, primaryKey = null, foreignKey = null) {
+        // I should get a query to get related records
+        const fk = foreignKey || this.#foreignKey;
+        const pk = primaryKey || this.id;
+        return await connection_1.default
+            .table(this.#table)
+            // in the form of model_id
+            .where(fk, pk)
+            .asCallback((err, rows) => {
+            if (err) {
+                throw err;
+            }
+            return rows;
+        });
+    }
+    /**
+     * Define a Many to many relationship relationship
+     * @param {String} related
+     */
+    belongsToMany(related, primaryKey = null, foreignKey = null) {
+        // look for a pivot table
+        // eg Farmer has many Crops crop_farmer is the table
+        // We'll use class names ['This Class, Related Class'].sort
+        const relatedName = related.toLowerCase();
+        const pivotTable = [this.#modelName, relatedName].sort().join('_');
+        const firstCol = `${this.#modelName}_id`;
+        const secondCol = `${relatedName}_id`;
+        // TODO Honestly I believe there is a better way
+        // Gets the related IDs from the pivot table
+        const firstQuery = connection_1.default
+            .table(pivotTable)
+            .where(firstCol, this.id)
+            .select(secondCol)
+            .toQuery();
+        // Get the records for the other table
+        return firstQuery;
+    }
+    /**
+         * Define a HasMany relationship
+         * @param {String} related
+         * @param {String} primaryKey
+         * @param {String} foreignKey
+         */
+    async hasMany(related, primaryKey = null, foreignKey = null) {
+        // I should get a query to get related records
+        const fk = foreignKey || this.#foreignKey;
+        const pk = primaryKey || this.id;
+        return await connection_1.default
+            .table(pluralize_1.default(related.toLowerCase()))
+            .where(fk, pk)
+            .select('*')
+            .asCallback((err, rows) => {
+            if (err) {
+                throw err;
+            }
+            return rows;
+        });
+    }
+    /**
+     * MorphOne relationship
+     * @param {String} related the class name of the other model
+     * @param {String} reference the reference column in the other model
+     */
+    async morphOne(related, reference) {
+        const foreign_id = `${reference}_id`;
+        const foreign_type = `${this.#modelName}_type`;
+        let condition = {};
+        condition[`${reference}_id`] = this.id;
+        condition[`${reference}_type`] = this.constructor.name;
+        const table = pluralize_1.default(related.toLocaleLowerCase());
+        return await connection_1.default.table(table)
+            .where(condition)
+            .first();
+    }
+    /**
+     * MorphMany relationship
+     * @param {String} related the class name of the other model
+     * @param {String} reference the reference column in the other model
+     */
+    async morphMany(related, reference) {
+        const foreign_id = `${reference}_id`;
+        const foreign_type = `${this.#modelName}_type`;
+        let condition = {};
+        condition[`${reference}_id`] = this.id;
+        condition[`${reference}_type`] = this.constructor.name;
+        const table = pluralize_1.default(related.toLocaleLowerCase());
+        return await connection_1.default.table(table)
+            .where(condition)
+            .select();
+    }
+}
+exports.default = Model;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mevn-orm",
-  "version": "2.3.5",
+  "version": "2.3.6",
   "description": "simple ORM for express js",
   "type": "commonjs",
   "scripts": {
@@ -11,8 +11,8 @@
     "lint": "eslint --ext .js ./"
   },
   "peerDependencies": {
-    "dotenv": "^15.0.0",
-    "knex": "^1.0.1",
+    "dotenv": "^16.0.0",
+    "knex": "^1.0.2",
     "mysql": "^2.18.1"
   },
   "peerDependenciesMeta": {
@@ -27,7 +27,11 @@
     "ORM",
     "express",
     "Mysql",
-    "mevn"
+    "mevn",
+    "database",
+    "orm",
+    "orm-express",
+    "orm-mysql"
   ],
   "author": "Stanley Masinde <stanmasinde@gmail.com> (https://stanleymasinde.github.io)",
   "contributors": [

package/.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,38 +0,0 @@
----
-name: Bug report
-about: Create a report to help us improve
-title: ''
-labels: ''
-assignees: ''
-
----
-
-**Describe the bug**
-A clear and concise description of what the bug is.
-
-**To Reproduce**
-Steps to reproduce the behavior:
-1. Go to '...'
-2. Click on '....'
-3. Scroll down to '....'
-4. See error
-
-**Expected behavior**
-A clear and concise description of what you expected to happen.
-
-**Screenshots**
-If applicable, add screenshots to help explain your problem.
-
-**Desktop (please complete the following information):**
- - OS: [e.g. iOS]
- - Browser [e.g. chrome, safari]
- - Version [e.g. 22]
-
-**Smartphone (please complete the following information):**
- - Device: [e.g. iPhone6]
- - OS: [e.g. iOS8.1]
- - Browser [e.g. stock browser, safari]
- - Version [e.g. 22]
-
-**Additional context**
-Add any other context about the problem here.

package/.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,20 +0,0 @@
----
-name: Feature request
-about: Suggest an idea for this project
-title: ''
-labels: ''
-assignees: ''
-
----
-
-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen.
-
-**Describe alternatives you've considered**
-A clear and concise description of any alternative solutions or features you've considered.
-
-**Additional context**
-Add any other context or screenshots about the feature request here.

package/.github/dependabot.yml

@@ -1,30 +0,0 @@
-version: 2
-updates:
-- package-ecosystem: npm
-  directory: '/'
-  schedule:
-    interval: daily
-    time: '00:00'
-  open-pull-requests-limit: 10
-  reviewers:
-    - stanleymasinde
-  assignees:
-    - stanleymasinde
-  commit-message:
-    prefix: fix
-    prefix-development: chore
-    include: scope
-- package-ecosystem: github-actions
-  directory: '/'
-  schedule:
-    interval: daily
-    time: '00:00'
-  open-pull-requests-limit: 10
-  reviewers:
-    - stanleymasinde
-  assignees:
-    - stanleymasinde
-  commit-message:
-    prefix: fix
-    prefix-development: chore
-    include: scope

package/.github/workflows/node.js.yml

@@ -1,31 +0,0 @@
-# This workflow will do a clean install of node dependencies, build the source code and run tests across different versions of node
-# For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
-
-name: Node.js CI
-
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-    branches: [ main ]
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        node-version: [12.x, 14.x, 15.x]
-        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
-
-    steps:
-    - uses: actions/checkout@v2
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v2
-      with:
-        node-version: ${{ matrix.node-version }}
-    - run: cp .env.example .env
-    - run: npm ci
-    - run: npm run build --if-present
-    - run: npm test

package/initDb

@@ -1,118 +0,0 @@
-#!/bin/env node
-const fs = require('fs')
-require('dotenv').config()
-const Knex = require('knex')
-
-let knexfilePath
-
-if (fs.existsSync(process.cwd() + '/knexfile.js')) {
-	knexfilePath = process.cwd() + '/knexfile.js'
-} else {
-	knexfilePath = process.cwd() + '/knexfile.cjs'
-}
-const { development, staging, production } = require(knexfilePath)
-let config
-
-switch (process.env.NODE_ENV) {
-case 'testing':
-	config = development
-	break
-case 'development':
-	config = development
-	break
-case 'staging':
-	config = staging
-	break
-default:
-	config = production
-	break
-}
-async function initDatabase() {
-	const DB = Knex(config)
-
-	try {
-		await DB.schema.dropTableIfExists('farmers')
-		await DB.schema.dropTableIfExists('farms')
-		await DB.schema.dropTableIfExists('profiles')
-		await DB.schema.dropTableIfExists('articles')
-		await DB.schema.createTable('farmers', (table) => {
-			table.bigIncrements('id')
-			table.string('name')
-			table.string('email').unique()
-			table.string('password')
-		})
-		await DB.schema.createTable('farms', (table) => {
-			table.bigIncrements('id')
-			table.bigInteger('farmer_id')
-			table.string('name')
-		})
-
-		await DB.schema.createTable('profiles', (table) => {
-			table.bigIncrements('id')
-			table.bigInteger('farmer_id')
-			table.string('bio')
-		})
-
-		await DB.schema.createTable('articles', (table) => {
-			table.bigIncrements('id')
-			table.string('title')
-			table.text('body')
-			table.bigInteger('postable_id')
-			table.string('postable_type')
-		})
-
-		await DB.table('Farmers').insert([
-			{
-				name: 'Jane Doe',
-				email: 'jane@mail.com',
-				password: 'pasword'
-			},
-			{
-				name: 'Ashley Doe',
-				email: 'ashley@mail.com',
-				password: 'pasword'
-			},
-			{
-				name: 'Alice Doe',
-				email: 'alice@mail.com',
-				password: 'pasword'
-			}
-		])
-
-		await DB.table('farms').insert([
-			{
-				farmer_id: 1,
-				name: 'Awesome Farm'
-			},
-			{
-				farmer_id: 1,
-				name: 'Awesome Farm two'
-			},
-			{
-				farmer_id: 1,
-				name: 'Awesome Farm three'
-			}
-		])
-
-		await DB.table('profiles').insert([
-			{
-				farmer_id: 1,
-				bio: 'Profile for farmer one'
-			}
-		])
-
-		await DB.table('articles').insert([
-			{
-				title: 'Awesome Post',
-				body: 'fffgjdfjdbdb something #1',
-				postable_id: 1,
-				postable_type: 'Farmer'
-			}
-		])
-
-		process.exit(0)
-	} catch (error) {
-		process.exit(1)
-	}
-}
-initDatabase()

package/test/model.test.js

@@ -1,87 +0,0 @@
-/* eslint-disable no-undef */
-const { Model, DB } = require('../index')
-const faker = require('faker')
-const { expect } = require('chai')
-class Profile extends Model {
-	fillable = ['farmer_id', 'bio']
-}
-class Farmer extends Model {
-	fillable = ['name', 'email', 'password']
-	hidden = ['password']
-
-	profile() {
-		return this.hasOne(Profile)
-	}
-}
-
-DB(Farmer)
-
-describe('#Model tests', () => {
-	it('#Model instance', async () => {
-		const farmer = new Farmer({
-			name: faker.name.findName(),
-			email: faker.internet.email(),
-			password: faker.internet.password()
-		})
-		await farmer.save()
-		expect(farmer).to.an('Object')
-	})
-
-	it('#find a model', async () => {
-		const farmer = await Farmer.find(1)
-		expect(farmer).to.an('Object')
-	})
-
-	it('#create a model', async () => {
-		const farmer = await Farmer.create({
-			name: faker.name.findName(),
-			email: faker.internet.email(),
-			password: faker.internet.password()
-		})
-		expect(farmer).to.an('Object')
-		expect(farmer.id).to.be.a('number')
-	})
-
-	it('#Update a model with a new instance', async () => {
-		const farmer = await Farmer.find(1)
-		await farmer.update({
-			name: 'new name',
-			email: faker.internet.email(),
-			password: faker.internet.password()
-		})
-		expect(farmer).to.an('Object')
-	})
-
-	it('#chain where and first', async () => {
-		const farmer = await Farmer.where({ id: 1 }).first()
-		expect(farmer).to.an('Object')
-	})
-
-	it('#Return null when not found', async () => {
-		const farmer = await Farmer.where({ id: 'ggggggg' }).first()
-		expect(farmer).to.be.null
-	})
-
-	it('#Delete a model', async () => {
-		const farmer = await Farmer.find(1)
-		await farmer.delete()
-		expect(await Farmer.find(1)).to.be.null
-	})
-
-	it('#Has one relationship', async () => {
-		const farmer = new Farmer({
-			name: faker.name.findName(),
-			email: faker.internet.email(),
-			password: faker.internet.password()
-		})
-		await farmer.save()
-		await new Profile({
-			farmer_id: farmer.id,
-			bio: faker.lorem.sentence()
-		}).save()
-
-		expect(farmer).to.an('Object')
-		const farmerProfile = await farmer.profile()
-		expect(farmerProfile).to.haveOwnProperty('farmer_id', farmer.id)
-	})
-})