mevn-orm 2.3.6 → 2.3.7

package/knexfile.js

@@ -12,7 +12,7 @@ module.exports = {
 	},
 
 	staging: {
-		client: process.env.DB_CLIENT || 'mysql2',
+		client: process.env.DB_CLIENT || 'mysql',
 		connection: {
 			database: process.env.DB_DATABASE || 'my_db',
 			user: process.env.DB_USER || 'username',
@@ -28,7 +28,7 @@ module.exports = {
 	},
 
 	production: {
-		client: process.env.DB_CLIENT || 'mysql2',
+		client: process.env.DB_CLIENT || 'mysql',
 		connection: {
 			database: process.env.DB_DATABASE || 'my_db',
 			user: process.env.DB_USER || 'username',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mevn-orm",
-  "version": "2.3.6",
+  "version": "2.3.7",
   "description": "simple ORM for express js",
   "type": "commonjs",
   "scripts": {
@@ -11,8 +11,8 @@
     "lint": "eslint --ext .js ./"
   },
   "peerDependencies": {
-    "dotenv": "^16.0.0",
-    "knex": "^1.0.2",
+    "dotenv": "^16.0.1",
+    "knex": "^2.1.0",
     "mysql": "^2.18.1"
   },
   "peerDependenciesMeta": {
@@ -47,21 +47,24 @@
     "@babel/eslint-parser": "^7.13.14",
     "@babel/eslint-plugin": "^7.13.16",
     "@babel/plugin-proposal-class-properties": "^7.14.5",
-    "@vscode/sqlite3": "^5.0.7",
     "chai": "^4.2.0",
     "dotenv": "^15.0.0",
     "eslint": "^7.25.0",
     "faker": "^5.5.3",
-    "knex": "^1.0.1",
+    "knex": "^2.1.0",
     "mocha": "^9.1.2",
-    "mysql2": "^2.3.0"
+    "mysql2": "^2.3.0",
+    "sqlite3": "^5.0.8"
   },
   "directories": {
     "lib": "lib",
     "test": "test"
   },
   "private": false,
-  "repository": "git+https://github.com/StanleyMasinde/mevn-orm.git",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/StanleyMasinde/mevn-orm.git"
+  },
   "bugs": {
     "url": "https://github.com/StanleyMasinde/mevn-orm/issues",
     "email": "stanmasinde@gmail.com"

package/dist/connection.d.ts

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

package/dist/connection.js

@@ -1,9 +0,0 @@
-"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

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

package/dist/index.js

@@ -1,9 +0,0 @@
-"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

@@ -1,171 +0,0 @@
-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

@@ -1,399 +0,0 @@
-"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;