mevn-orm 3.2.2 → 4.0.0

package/src/relationships.ts

@@ -0,0 +1,93 @@
+import type { Knex } from 'knex'
+
+type Row = Record<string, unknown>
+
+interface RelationshipModel {
+	[key: string]: unknown
+	table: string
+	modelName: string
+	id?: number | string
+	stripColumns<T extends RelationshipModel>(model: T, keepInternalState?: boolean): T
+}
+
+type RelatedModelCtor = new (properties?: Row) => RelationshipModel
+
+interface RelationshipMethods {
+	hasOne(
+		this: RelationshipModel,
+		Related: RelatedModelCtor,
+		localKey?: number | string,
+		foreignKey?: string,
+	): Promise<RelationshipModel | null>
+	hasMany(
+		this: RelationshipModel,
+		Related: RelatedModelCtor,
+		localKey?: number | string,
+		foreignKey?: string,
+	): Promise<RelationshipModel[]>
+	belongsTo(
+		this: RelationshipModel,
+		Related: RelatedModelCtor,
+		foreignKey?: string,
+		ownerKey?: string,
+	): Promise<RelationshipModel | null>
+}
+
+/** Builds relationship methods that run against the active Knex instance. */
+const createRelationshipMethods = (getDB: () => Knex): RelationshipMethods => ({
+	async hasOne(this: RelationshipModel, Related: RelatedModelCtor, localKey?: number | string, foreignKey?: string) {
+		const table = new Related().table
+		const relation: Row = {}
+		const keyValue = localKey ?? this.id
+		const relationKey = foreignKey ?? `${this.modelName}_id`
+
+		if (keyValue !== undefined) {
+			relation[relationKey] = keyValue
+			const result = await getDB()(table).where(relation).first<Row>()
+			if (result) {
+				const related = new Related(result)
+				return related.stripColumns(related)
+			}
+		}
+
+		return null
+	},
+	async hasMany(this: RelationshipModel, Related: RelatedModelCtor, localKey?: number | string, foreignKey?: string) {
+		const table = new Related().table
+		const relation: Row = {}
+		const keyValue = localKey ?? this.id
+		const relationKey = foreignKey ?? `${this.modelName}_id`
+
+		if (keyValue === undefined) {
+			return []
+		}
+
+		relation[relationKey] = keyValue
+		const rows = await getDB()(table).where(relation).select<Row[]>('*')
+		return rows.map((row) => {
+			const related = new Related(row)
+			return related.stripColumns(related)
+		})
+	},
+	async belongsTo(this: RelationshipModel, Related: RelatedModelCtor, foreignKey?: string, ownerKey = 'id') {
+		const table = new Related().table
+		const relation: Row = {}
+		const relationKey = foreignKey ?? `${new Related().modelName}_id`
+		const relationValue = this[relationKey]
+
+		if (relationValue === undefined || relationValue === null) {
+			return null
+		}
+
+		relation[ownerKey] = relationValue
+		const row = await getDB()(table).where(relation).first<Row>()
+		if (!row) {
+			return null
+		}
+
+		const related = new Related(row)
+		return related.stripColumns(related)
+	},
+})
+
+export { createRelationshipMethods }

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "noImplicitOverride": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "useUnknownInCatchVariables": true,
+    "noEmit": true,
+    "skipLibCheck": false,
+    "esModuleInterop": false,
+    "forceConsistentCasingInFileNames": true,
+    "types": [
+      "node",
+      "vitest/globals"
+    ]
+  },
+  "include": [
+    "**/*.ts",
+    "**/*.d.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}

package/types/pluralize.d.ts

@@ -0,0 +1,4 @@
+declare module 'pluralize' {
+	function pluralize(word: string): string
+	export default pluralize
+}

package/index.js

@@ -1,3 +0,0 @@
-require('dotenv').config()
-const {Model, DB} = require('./lib/model')
-module.exports = { Model, DB }

package/knexfile.js

@@ -1,46 +0,0 @@
-module.exports = {
-
-	development: {
-		client: 'sqlite3',
-		connection: {
-			filename: './dev.sqlite'
-		},
-		useNullAsDefault: true,
-		migrations: {
-			tableName: 'migrations',
-		}
-	},
-
-	staging: {
-		client: process.env.DB_CLIENT || 'mysql2',
-		connection: {
-			database: process.env.DB_DATABASE || 'my_db',
-			user: process.env.DB_USER || 'username',
-			password: process.env.DB_PASSWORD || 'password'
-		},
-		pool: {
-			min: 2,
-			max: 10
-		},
-		migrations: {
-			tableName: 'migrations'
-		}
-	},
-
-	production: {
-		client: process.env.DB_CLIENT || 'mysql2',
-		connection: {
-			database: process.env.DB_DATABASE || 'my_db',
-			user: process.env.DB_USER || 'username',
-			password: process.env.DB_PASSWORD || 'password'
-		},
-		pool: {
-			min: 2,
-			max: 10
-		},
-		migrations: {
-			tableName: 'migrations'
-		}
-	}
-
-}

package/lib/model.js

@@ -1,252 +0,0 @@
-const fs = require('fs')
-const knex = require('knex').knex
-
-let fileName
-
-if (fs.existsSync(process.cwd() + '/knexfile.js')) {
-	fileName = process.cwd() + '/knexfile.js'
-} else {
-	fileName = process.cwd() + '/knexfile.cjs'
-}
-const { development, staging, production } = require(fileName)
-
-const pluralize = require('pluralize')
-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
-}
-const DB = knex(config)
-class Model {
-	#private
-	static currentTable = pluralize(this.name.toLowerCase())
-	static currentQuery
-	constructor(properties) {
-		for (const key in properties) {
-			this[key] = properties[key]
-		}
-		this.fillable = []
-		this.hidden = []
-		this.#private = ['fillable', 'hidden']
-		this.modelName = this.constructor.name.toLowerCase()
-		this.table = pluralize(this.constructor.name.toLowerCase())
-	}
-
-	/**
-	 * Save a model to the database
-	 */
-	async save() {
-		try {
-			let rows = {}
-			this.fillable.forEach((f) => {
-				rows[f] = this[f]
-			})
-			const [id] = await DB(this.table)
-				.insert(rows)
-			const fields = await DB(this.table).where({ id }).first()
-			for (const f in fields) {
-				this[f] = fields[f]
-			}
-			this['id'] = id
-			return this.stripColumns(this)
-		} catch (error) {
-			throw new Error(error)
-		}
-	}
-
-	/**
-	 * Update a model
-	 * @param {*} properties
-	 * @returns this
-	 */
-	async update(properties) {
-		try {
-			const id = await DB(this.table)
-				.where({ id: this.id })
-				.update(properties)
-			const fields = await DB(this.table).where({ id }).first()
-			// console.log(fields)
-			return this.stripColumns(new this.constructor(fields))
-		} catch (error) {
-			throw new Error(error)
-		}
-	}
-
-	/**
-	 * Delete a model
-	 * @returns this
-	 */
-	async delete() {
-		try {
-			await DB(this.table)
-				.where({ id: this.id })
-				.del()
-			return
-		} catch (error) {
-			throw new Error(error)
-		}
-	}
-
-
-	/**
-	 * Update a model
-	 * @param {*} properties
-	 * @returns
-	 */
-	static async update(properties) {
-		try {
-			if (!this.currentQuery) {
-				const rows = await DB(this.table).update(properties)
-				return rows
-			}
-		} catch (error) {
-			throw new Error(error)
-		}
-	}
-
-	/**
-	 * Delete a model
-	 * @returns
-	 */
-	static async destroy() {
-		try {
-			if (!this.currentQuery) {
-				const rows = await DB(this.table).delete()
-				return rows
-			}
-		} catch (error) {
-			throw new Error(error)
-		}
-	}
-
-	/**
-	 * Find a model
-	 * @param {*} id
-	 * @param {*} columns
-	 * @returns this
-	 */
-	static async find(id, columns = '*') {
-		const table = pluralize(this.name.toLowerCase())
-		try {
-			const fields = await DB(table)
-				.where({ id })
-				.first(columns)
-			if (fields) {
-				return new this(fields)
-			}
-			return null
-		} catch (error) {
-			throw new Error(error)
-		}
-	}
-
-	/**
-	 * Create a new model
-	 * @param {*} properties
-	 * @returns this
-	 */
-	static async create(properties) {
-		const table = pluralize(this.name.toLowerCase())
-		try {
-			const fields = await DB(table)
-				.insert(properties)
-			const record = await DB(table).where({ id: fields[0] }).first()
-			const model = new this(record)
-			return model.stripColumns(model)
-		} catch (error) {
-			throw new Error(error)
-		}
-	}
-
-	/**
-	 * --------------|
-	 * Relationships |
-	 * --------------|
-	 */
-
-	/**
-	 * One to one relationship
-	 * @param {*} related 
-	 */
-	async hasOne(Related, localKey, foreignKey) {
-		const table = new Related().table
-		const relation = {}
-		if (!localKey) {
-			localKey = this.id
-		}
-		if (!foreignKey) {
-			foreignKey = `${this.modelName}_id`
-		}
-
-		if (localKey) {
-			relation[foreignKey] = localKey
-			const res = await DB(table).where(relation).first()
-			if (res) {
-				return this.stripColumns(new Related(res))
-			}
-		}
-		return null
-	}
-	// hasMany(related) {}
-	// hasManyThrough(related) {}
-	// belongsTo(related) {}
-	// belongsToMany(related) {}
-
-	/**
-	 * Where condition
-	 * @param {*} conditions 
-	 * @returns 
-	 */
-	static where(conditions = {}) {
-		const table = pluralize(this.name.toLowerCase())
-		this.currentQuery = DB(table).where(conditions)
-		return this
-	}
-
-	/*ß
-	 * Return the first model
-	 * @param {*} columns 
-	 */
-	static async first(columns = '*') {
-		try {
-			if (!this.currentQuery) {
-				const rows = await DB(this.table).first(columns)
-				if (rows) {
-					return new this(rows)
-				}
-				return null
-			}
-			const rows = await this.currentQuery.first(columns)
-			if (rows) {
-				return new this(rows)
-			}
-			return null
-		} catch (error) {
-			throw new Error(error)
-		}
-	}
-
-
-	/**
-	 * Delete columns that are not needed
-	 * 
-	 */
-	stripColumns(model) {
-		this.#private.concat(this.hidden).forEach((h) => {
-			delete model[h]
-		})
-		return model
-	}
-
-}
-module.exports = { Model, DB }