@h3ravel/arquebus 0.6.6 → 0.6.8

package/bin/{index.js → index.mjs}

@@ -1,11 +1,10 @@
 #!/usr/bin/env node
-import "./seeders-CltigymO.js";
 import "node:module";
 import { Argument, Option, program } from "commander";
 import { FileSystem, Logger, TaskManager } from "@h3ravel/shared";
 import path from "path";
 import resolveFrom from "resolve-from";
-import fs, { copyFile, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import fs, { access, copyFile, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
 import { assign, camel, diff, flat, get, isArray, isEmpty, isEqual, isString, omit, pick, set, snake, trim } from "radashi";
 import advancedFormat from "dayjs/plugin/advancedFormat.js";
 import dayjs from "dayjs";
@@ -22,8 +21,8 @@ import { config } from "dotenv";
 var __defProp = Object.defineProperty;
 var __export = (all) => {
 	let target = {};
-	for (var name$1 in all) __defProp(target, name$1, {
-		get: all[name$1],
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
 		enumerable: true
 	});
 	return target;
@@ -128,8 +127,8 @@ var MigrationRepository = class {
 	getConnection() {
 		return this.resolver.fire(this.connection);
 	}
-	setSource(name$1) {
-		this.connection = name$1;
+	setSource(name) {
+		this.connection = name;
 	}
 };
 
@@ -603,10 +602,7 @@ var MSSQL = class {
         AND ISNULL([i].[index_column_count], 1) = 1
         AND ISNULL([i].[index_priority], 1) = 1`).where({ "s.name": this.schema });
 		if (table) query.andWhere({ "o.name": table });
-		if (column) {
-			const rawColumn = await query.andWhere({ "c.name": column }).first();
-			return rawColumnToColumn$2(rawColumn);
-		}
+		if (column) return rawColumnToColumn$2(await query.andWhere({ "c.name": column }).first());
 		return (await query).map(rawColumnToColumn$2);
 	}
 	/**
@@ -757,10 +753,7 @@ var MySQL = class {
 			this.on("rc.TABLE_NAME", "=", "fk.TABLE_NAME").andOn("rc.CONSTRAINT_NAME", "=", "fk.CONSTRAINT_NAME").andOn("rc.CONSTRAINT_SCHEMA", "=", "fk.CONSTRAINT_SCHEMA");
 		}).where({ "c.TABLE_SCHEMA": this.knex.client.database() });
 		if (table) query.andWhere({ "c.TABLE_NAME": table });
-		if (column) {
-			const rawColumn = await query.andWhere({ "c.column_name": column }).first();
-			return rawColumnToColumn$1(rawColumn);
-		}
+		if (column) return rawColumnToColumn$1(await query.andWhere({ "c.column_name": column }).first());
 		return (await query).map(rawColumnToColumn$1).sort((column$1) => +!column$1.foreign_key_column).filter((column$1, index, records) => {
 			return records.findIndex((_column) => {
 				return column$1.name === _column.name && column$1.table === _column.table;
@@ -859,7 +852,7 @@ var oracleDB = class {
 		return (await this.knex.select(this.knex.raw(`
           /*+ OPTIMIZER_FEATURES_ENABLE('${OPTIMIZER_FEATURES}') */
             "TABLE_NAME" "name"
-        `)).from("USER_TABLES")).map(({ name: name$1 }) => name$1);
+        `)).from("USER_TABLES")).map(({ name }) => name);
 	}
 	async tableInfo(table) {
 		const query = this.knex.select(this.knex.raw(`
@@ -946,10 +939,7 @@ var oracleDB = class {
             ON "ct"."R_CONSTRAINT_NAME" = "fk"."CONSTRAINT_NAME"
         `)).where({ "c.HIDDEN_COLUMN": "NO" });
 		if (table) query.andWhere({ "c.TABLE_NAME": table });
-		if (column) {
-			const rawColumn = await query.andWhere({ "c.COLUMN_NAME": column }).first();
-			return rawColumnToColumn(rawColumn);
-		}
+		if (column) return rawColumnToColumn(await query.andWhere({ "c.COLUMN_NAME": column }).first());
 		return (await query).map(rawColumnToColumn);
 	}
 	/**
@@ -1365,8 +1355,8 @@ var Postgres = class {
 * Extracts the length value out of a given datatype
 * For example: `varchar(32)` => 32
 */
-function extractMaxLength(type$1) {
-	const matches = /\(([^)]+)\)/.exec(type$1);
+function extractMaxLength(type) {
+	const matches = /\(([^)]+)\)/.exec(type);
 	if (matches && matches.length > 0 && matches[1]) return Number(matches[1]);
 	return null;
 }
@@ -1377,8 +1367,8 @@ function extractMaxLength(type$1) {
 * Extracts the type out of a given datatype
 * For example: `varchar(32)` => varchar
 */
-function extractType(type$1) {
-	return type$1.replace(/[^a-zA-Z]/g, "").toLowerCase();
+function extractType(type) {
+	return type.replace(/[^a-zA-Z]/g, "").toLowerCase();
 }
 
 //#endregion
@@ -1511,8 +1501,8 @@ function compose$1(Base, ...mixins) {
 				/**
 				* Copy instance properties from mixin prototype
 				*/
-				Object.getOwnPropertyNames(mixin.prototype).forEach((name$1) => {
-					if (name$1 !== "constructor") Object.defineProperty(this, name$1, Object.getOwnPropertyDescriptor(mixin.prototype, name$1));
+				Object.getOwnPropertyNames(mixin.prototype).forEach((name) => {
+					if (name !== "constructor") Object.defineProperty(this, name, Object.getOwnPropertyDescriptor(mixin.prototype, name));
 				});
 			}
 		};
@@ -1836,9 +1826,7 @@ const HasAttributes = (Model$1) => {
 		}
 		originalIsEquivalent(key) {
 			if (this.original[key] === void 0) return false;
-			const attribute = this.attributes[key];
-			const original = this.original[key];
-			if (attribute === original) return true;
+			if (this.attributes[key] === this.original[key]) return true;
 			else return false;
 		}
 		setAttributes(attributes) {
@@ -1980,10 +1968,10 @@ const HasAttributes = (Model$1) => {
 			else convertedCastType = String(castType).toLocaleLowerCase().trim();
 			return this.getConstructor()[castTypeCacheKey] = convertedCastType;
 		}
-		hasCast(key, types$1 = []) {
+		hasCast(key, types = []) {
 			if (key in this.casts) {
-				types$1 = flat(types$1);
-				return types$1.length > 0 ? types$1.includes(this.getCastType(key)) : true;
+				types = flat(types);
+				return types.length > 0 ? types.includes(this.getCastType(key)) : true;
 			}
 			return false;
 		}
@@ -2020,8 +2008,7 @@ const HasAttributes = (Model$1) => {
 			return new Date(value);
 		}
 		asDate(value) {
-			const date = this.asDateTime(value);
-			return dayjs(date).startOf("day").toDate();
+			return dayjs(this.asDateTime(value)).startOf("day").toDate();
 		}
 	};
 };
@@ -2160,15 +2147,15 @@ var has_hooks_default = HasHooks;
 //#region src/relations/has-one-or-many.ts
 const HasOneOrMany = (Relation$1) => {
 	return class extends Relation$1 {
-		getRelationValue(dictionary, key, type$1) {
+		getRelationValue(dictionary, key, type) {
 			const value = dictionary[key];
-			return type$1 === "one" ? value[0] : new collection_default(value);
+			return type === "one" ? value[0] : new collection_default(value);
 		}
-		matchOneOrMany(models, results, relation, type$1) {
+		matchOneOrMany(models, results, relation, type) {
 			const dictionary = this.buildDictionary(results);
 			models.map((model) => {
 				const key = model.attributes[this.localKey];
-				if (dictionary[key] !== void 0) model.setRelation(relation, this.getRelationValue(dictionary, key, type$1));
+				if (dictionary[key] !== void 0) model.setRelation(relation, this.getRelationValue(dictionary, key, type));
 			});
 			return models;
 		}
@@ -2535,10 +2522,7 @@ const HasRelations = (Model$1) => {
 			return this.relations[relation] !== void 0;
 		}
 		related(relation) {
-			if (typeof this[getRelationMethod(relation)] !== "function") {
-				const message = `Model [${this.constructor.name}]'s relation [${relation}] doesn't exist.`;
-				throw new RelationNotFoundError(message);
-			}
+			if (typeof this[getRelationMethod(relation)] !== "function") throw new RelationNotFoundError(`Model [${this.constructor.name}]'s relation [${relation}] doesn't exist.`);
 			return this[getRelationMethod(relation)]();
 		}
 		async getRelated(relation) {
@@ -3049,8 +3033,8 @@ var arquebus = class arquebus {
 	static getConnectorFactory() {
 		return this.connectorFactory ?? Knex;
 	}
-	static addConnection(config$1, name$1 = "default") {
-		return this.getInstance().addConnection(config$1, name$1);
+	static addConnection(config$1, name = "default") {
+		return this.getInstance().addConnection(config$1, name);
 	}
 	static beginTransaction(connection = null) {
 		return this.getInstance().beginTransaction(connection);
@@ -3058,8 +3042,8 @@ var arquebus = class arquebus {
 	static transaction(callback, connection = null) {
 		return this.getInstance().transaction(callback, connection);
 	}
-	static table(name$1, connection = null) {
-		return this.getInstance().table(name$1, connection);
+	static table(name, connection = null) {
+		return this.getInstance().table(name, connection);
 	}
 	static schema(connection = null) {
 		return this.getInstance().schema(connection);
@@ -3067,23 +3051,23 @@ var arquebus = class arquebus {
 	static async destroyAll() {
 		await this.getInstance().destroyAll();
 	}
-	static createModel(name$1, options) {
-		return this.getInstance().createModel(name$1, options);
+	static createModel(name, options) {
+		return this.getInstance().createModel(name, options);
 	}
 	connection(connection = null) {
 		return this.getConnection(connection);
 	}
-	getConnection(name$1 = null) {
-		name$1 = name$1 || "default";
-		const resolvedName = this.connections[name$1] ? name$1 : "default";
+	getConnection(name = null) {
+		name = name || "default";
+		const resolvedName = this.connections[name] ? name : "default";
 		if (this.manager[resolvedName] === void 0) {
 			const queryBuilder = new query_builder_default(this.connections[resolvedName], arquebus.getConnectorFactory());
 			this.manager[resolvedName] = queryBuilder;
 		}
 		return this.manager[resolvedName];
 	}
-	addConnection(config$1, name$1 = "default") {
-		this.connections[name$1] = {
+	addConnection(config$1, name = "default") {
+		this.connections[name] = {
 			...config$1,
 			connection: {
 				...config$1.connection,
@@ -3145,8 +3129,8 @@ var arquebus = class arquebus {
 	transaction(callback, connection = null) {
 		return this.connection(connection).transaction(callback);
 	}
-	table(name$1, connection = null) {
-		return this.connection(connection).table(name$1);
+	table(name, connection = null) {
+		return this.connection(connection).table(name);
 	}
 	schema(connection = null) {
 		return this.connection(connection).schema;
@@ -3156,12 +3140,12 @@ var arquebus = class arquebus {
 			return connection === null || connection === void 0 ? void 0 : connection.destroy();
 		}));
 	}
-	createModel(name$1, options = {}) {
+	createModel(name, options = {}) {
 		let BaseModel$1 = Model;
 		if ("plugins" in options) BaseModel$1 = compose(BaseModel$1, ...options.plugins ?? []);
 		this.models = {
 			...this.models,
-			[name$1]: class extends BaseModel$1 {
+			[name]: class extends BaseModel$1 {
 				table = (options === null || options === void 0 ? void 0 : options.table) ?? null;
 				connection = (options === null || options === void 0 ? void 0 : options.connection) ?? null;
 				timestamps = (options === null || options === void 0 ? void 0 : options.timestamps) ?? true;
@@ -3177,18 +3161,18 @@ var arquebus = class arquebus {
 		};
 		if ("attributes" in options) for (const attribute in options.attributes) {
 			if (options.attributes[attribute] instanceof attribute_default === false) throw new Error("Attribute must be an instance of \"Attribute\"");
-			this.models[name$1].prototype[getAttrMethod(attribute)] = () => {
+			this.models[name].prototype[getAttrMethod(attribute)] = () => {
 				var _options$attributes;
 				return (_options$attributes = options.attributes) === null || _options$attributes === void 0 ? void 0 : _options$attributes[attribute];
 			};
 		}
-		if ("relations" in options) for (const relation in options.relations) this.models[name$1].prototype[getRelationMethod(relation)] = function() {
+		if ("relations" in options) for (const relation in options.relations) this.models[name].prototype[getRelationMethod(relation)] = function() {
 			var _options$relations;
 			return (_options$relations = options.relations) === null || _options$relations === void 0 ? void 0 : _options$relations[relation](this);
 		};
-		if ("scopes" in options) for (const scope in options.scopes) this.models[name$1].prototype[getScopeMethod(scope)] = options.scopes[scope];
-		this.models[name$1].setConnectionResolver(this);
-		return this.models[name$1];
+		if ("scopes" in options) for (const scope in options.scopes) this.models[name].prototype[getScopeMethod(scope)] = options.scopes[scope];
+		this.models[name].setConnectionResolver(this);
+		return this.models[name];
 	}
 };
 var arquebus_default = arquebus;
@@ -3348,8 +3332,8 @@ var Model = class Model extends BaseModel {
 		}
 		return builder;
 	}
-	hasNamedScope(name$1) {
-		const scope = getScopeMethod(name$1);
+	hasNamedScope(name) {
+		const scope = getScopeMethod(name);
 		return typeof this[scope] === "function";
 	}
 	callNamedScope(scope, parameters) {
@@ -3833,8 +3817,8 @@ const InteractsWithPivotTable = (Relation$1) => {
 		castKey(key) {
 			return this.getTypeSwapValue(this.related.getKeyType(), key);
 		}
-		getTypeSwapValue(type$1, value) {
-			switch (type$1.toLowerCase()) {
+		getTypeSwapValue(type, value) {
+			switch (type.toLowerCase()) {
 				case "int":
 				case "integer": return parseInt(value);
 				case "real":
@@ -4039,8 +4023,7 @@ var BelongsToMany = class extends compose(relation_default, interacts_with_pivot
 		return columns.concat(this.aliasedPivotColumns());
 	}
 	aliasedPivotColumns() {
-		const defaults = [this.foreignPivotKey, this.relatedPivotKey];
-		return collect$1(defaults.concat(this.pivotColumns)).map((column) => {
+		return collect$1([this.foreignPivotKey, this.relatedPivotKey].concat(this.pivotColumns)).map((column) => {
 			return this.qualifyPivotColumn(column) + " as pivot_" + column;
 		}).unique().all();
 	}
@@ -4333,8 +4316,7 @@ var Builder = class Builder extends Inference {
 	}
 	addUpdatedAtColumn(values) {
 		if (!this.model.usesTimestamps() || this.model.getUpdatedAtColumn() === null) return values;
-		const column = this.model.getUpdatedAtColumn();
-		values = assign({ [column]: this.model.freshTimestampString() }, values);
+		values = assign({ [this.model.getUpdatedAtColumn()]: this.model.freshTimestampString() }, values);
 		return values;
 	}
 	delete() {
@@ -4384,8 +4366,8 @@ var Builder = class Builder extends Inference {
 		}
 		return this;
 	}
-	hasNamedScope(name$1) {
-		return this.model && this.model.hasNamedScope(name$1);
+	hasNamedScope(name) {
+		return this.model && this.model.hasNamedScope(name);
 	}
 	callNamedScope(scope, parameters) {
 		return this.model.callNamedScope(scope, [this, ...parameters]);
@@ -4410,15 +4392,15 @@ var Builder = class Builder extends Inference {
 		this.globalScopes = omit(this.globalScopes, [scope]);
 		return this;
 	}
-	macro(name$1, callback) {
-		this.localMacros[name$1] = callback;
+	macro(name, callback) {
+		this.localMacros[name] = callback;
 		return this;
 	}
-	hasMacro(name$1) {
-		return name$1 in this.localMacros;
+	hasMacro(name) {
+		return name in this.localMacros;
 	}
-	getMacro(name$1) {
-		return this.localMacros[name$1];
+	getMacro(name) {
+		return this.localMacros[name];
 	}
 	with(...args) {
 		let eagerLoads = {};
@@ -4499,8 +4481,8 @@ var Builder = class Builder extends Inference {
 		return this.canUseExistsForExistenceCheck(operator, count) ? this.addWhereExistsQuery(hasQuery.getQuery(), boolean, operator === "<" && count === 1) : this.addWhereCountQuery(hasQuery.getQuery(), operator, count, boolean);
 	}
 	addWhereExistsQuery(query, boolean = "and", not = false) {
-		const type$1 = not ? "NotExists" : "Exists";
-		const method = boolean === "and" ? "where" + type$1 : "orWhere" + type$1;
+		const type = not ? "NotExists" : "Exists";
+		const method = boolean === "and" ? "where" + type : "orWhere" + type;
 		this[method](query.connector);
 		return this;
 	}
@@ -4522,12 +4504,12 @@ var Builder = class Builder extends Inference {
 		const db = this.model.getConnection();
 		if (this.query._statements.filter((item) => item.grouping == "columns").map((item) => item.value).flat().length === 0) this.query.select([this.query._single.table + ".*"]);
 		const parses = this.parseWithRelations(relations);
-		for (let name$1 in parses) {
-			const constraints = parses[name$1];
-			const segments = name$1.split(" ");
+		for (let name in parses) {
+			const constraints = parses[name];
+			const segments = name.split(" ");
 			let alias, expression;
-			if (segments.length === 3 && segments[1].toLocaleLowerCase() === "as") [name$1, alias] = [segments[0], segments[2]];
-			const relation = this.getRelationWithoutConstraints(getRelationMethod(name$1));
+			if (segments.length === 3 && segments[1].toLocaleLowerCase() === "as") [name, alias] = [segments[0], segments[2]];
+			const relation = this.getRelationWithoutConstraints(getRelationMethod(name));
 			if (action) {
 				const hashedColumn = this.query._single.table === relation.query.query._single.table ? `${relation.getRelationCountHash(false)}.${column}` : column;
 				const wrappedColumn = column === "*" ? column : relation.getRelated().qualifyColumn(hashedColumn);
@@ -4535,7 +4517,7 @@ var Builder = class Builder extends Inference {
 			} else expression = column;
 			const query = relation.getRelationExistenceQuery(relation.getRelated().newModelQuery(), this, db.raw(expression));
 			constraints(query);
-			alias = alias || snake(`${name$1} ${action} ${column}`.replace("/[^[:alnum:][:space:]_]/u", ""));
+			alias = alias || snake(`${name} ${action} ${column}`.replace("/[^[:alnum:][:space:]_]/u", ""));
 			if (action === "exists") this.select(db.raw(`exists(${query.toSql().sql}) as ${alias}`));
 			else this.selectSub(action ? query : query.limit(1), alias);
 		}
@@ -4596,15 +4578,15 @@ var Builder = class Builder extends Inference {
 		if (relations.length === 0) return [];
 		let results = {};
 		const constraintsMap = this.prepareNestedWithRelationships(relations);
-		for (const name$1 in constraintsMap) {
-			results = this.addNestedWiths(name$1, results);
-			results[name$1] = constraintsMap[name$1];
+		for (const name in constraintsMap) {
+			results = this.addNestedWiths(name, results);
+			results[name] = constraintsMap[name];
 		}
 		return results;
 	}
-	addNestedWiths(name$1, results) {
+	addNestedWiths(name, results) {
 		const progress = [];
-		name$1.split(".").map((segment) => {
+		name.split(".").map((segment) => {
 			progress.push(segment);
 			const last = progress.join(".");
 			if (results[last] === void 0) results[last] = () => {};
@@ -4637,22 +4619,19 @@ var Builder = class Builder extends Inference {
 			return builder;
 		};
 	}
-	parseNameAndAttributeSelectionConstraint(name$1, value) {
-		return name$1.includes(":") ? this.createSelectWithConstraint(name$1) : [name$1, value];
+	parseNameAndAttributeSelectionConstraint(name, value) {
+		return name.includes(":") ? this.createSelectWithConstraint(name) : [name, value];
 	}
-	createSelectWithConstraint(name$1) {
-		return [name$1.split(":")[0], (query) => {
-			query.select(name$1.split(":")[1].split(",").map((column) => {
+	createSelectWithConstraint(name) {
+		return [name.split(":")[0], (query) => {
+			query.select(name.split(":")[1].split(",").map((column) => {
 				if (column.includes(".")) return column;
 				return query instanceof belongs_to_many_default ? query.related.getTable() + "." + column : column;
 			}));
 		}];
 	}
 	related(relation) {
-		if (typeof this.model[getRelationMethod(relation)] !== "function") {
-			const message = `Model [${this.model.constructor.name}]'s relation [${relation}] doesn't exist.`;
-			throw new RelationNotFoundError(message);
-		}
+		if (typeof this.model[getRelationMethod(relation)] !== "function") throw new RelationNotFoundError(`Model [${this.model.constructor.name}]'s relation [${relation}] doesn't exist.`);
 		return this.model[getRelationMethod(relation)]();
 	}
 	take(...args) {
@@ -4725,8 +4704,7 @@ var Builder = class Builder extends Inference {
 		return await this.whereIn(this.model.getKeyName(), ids).get(columns);
 	}
 	async pluck(column) {
-		const data = await this.query.pluck(column);
-		return new collection_default(data);
+		return new collection_default(await this.query.pluck(column));
 	}
 	async destroy(ids) {
 		if (ids instanceof collection_default) ids = ids.modelKeys();
@@ -4770,37 +4748,34 @@ var Builder = class Builder extends Inference {
 		}
 		return this.hydrate(await this.query.get()).all();
 	}
-	getRelation(name$1) {
-		if (typeof this.model[getRelationMethod(name$1)] !== "function") {
-			const message = `Model [${this.model.constructor.name}]'s relation [${name$1}] doesn't exist.`;
-			throw new RelationNotFoundError(message);
-		}
-		const relation = relation_default.noConstraints(() => this.model.newInstance(this.model.attributes)[getRelationMethod(name$1)]());
-		const nested = this.relationsNestedUnder(name$1);
+	getRelation(name) {
+		if (typeof this.model[getRelationMethod(name)] !== "function") throw new RelationNotFoundError(`Model [${this.model.constructor.name}]'s relation [${name}] doesn't exist.`);
+		const relation = relation_default.noConstraints(() => this.model.newInstance(this.model.attributes)[getRelationMethod(name)]());
+		const nested = this.relationsNestedUnder(name);
 		if (Object.keys(nested).length > 0) relation.query.with(nested);
 		return relation.asProxy();
 	}
 	relationsNestedUnder(relation) {
 		const nested = {};
-		for (const name$1 in this.eagerLoad) {
-			const constraints = this.eagerLoad[name$1];
-			if (this.isNestedUnder(relation, name$1)) nested[name$1.substring((relation + ".").length)] = constraints;
+		for (const name in this.eagerLoad) {
+			const constraints = this.eagerLoad[name];
+			if (this.isNestedUnder(relation, name)) nested[name.substring((relation + ".").length)] = constraints;
 		}
 		return nested;
 	}
-	isNestedUnder(relation, name$1) {
-		return name$1.includes(".") && name$1.startsWith(relation + ".");
+	isNestedUnder(relation, name) {
+		return name.includes(".") && name.startsWith(relation + ".");
 	}
-	async eagerLoadRelation(models, name$1, constraints) {
-		const relation = this.getRelation(name$1);
+	async eagerLoadRelation(models, name, constraints) {
+		const relation = this.getRelation(name);
 		relation.addEagerConstraints(models);
 		constraints(relation);
-		return relation.match(relation.initRelation(models, name$1), await relation.get(), name$1);
+		return relation.match(relation.initRelation(models, name), await relation.get(), name);
 	}
 	async eagerLoadRelations(models) {
-		for (const name$1 in this.eagerLoad) {
-			const constraints = this.eagerLoad[name$1];
-			if (!name$1.includes(".")) models = await this.eagerLoadRelation(models, name$1, constraints);
+		for (const name in this.eagerLoad) {
+			const constraints = this.eagerLoad[name];
+			if (!name.includes(".")) models = await this.eagerLoadRelation(models, name, constraints);
 		}
 		return models;
 	}
@@ -4813,6 +4788,79 @@ var Builder = class Builder extends Inference {
 };
 var builder_default = Builder;
 
+//#endregion
+//#region src/seeders/runner.ts
+async function glob$1(folderPath) {
+	const { default: escalade } = await import("escalade");
+	const entries = [];
+	await escalade(folderPath, async (dir, names) => {
+		await Promise.all(names.map(async (name) => {
+			const p = path.join(dir, name);
+			try {
+				await access(p);
+				if (p.endsWith(".js") || p.endsWith(".ts")) entries.push(p);
+			} catch {}
+		}));
+		return "";
+	});
+	return entries;
+}
+var SeederRunner = class {
+	resolver;
+	connection;
+	paths = [];
+	constructor(resolver) {
+		this.resolver = resolver;
+	}
+	path(p) {
+		this.paths = Array.from(new Set([...this.paths, p]));
+	}
+	getPaths() {
+		return this.paths;
+	}
+	resolveConnection(connection) {
+		var _getInstance, _ref, _instance$connections;
+		const name = connection || this.connection || "default";
+		const instance = ((_getInstance = (_ref = this.resolver).getInstance) === null || _getInstance === void 0 ? void 0 : _getInstance.call(_ref)) ?? null;
+		if (!!!(instance === null || instance === void 0 || (_instance$connections = instance.connections) === null || _instance$connections === void 0 ? void 0 : _instance$connections[name])) this.resolver.autoLoad().catch(() => {
+			/** noop */
+		});
+		return this.resolver.fire(name);
+	}
+	setConnection(connection) {
+		this.connection = connection;
+		return this;
+	}
+	async getSeederFiles(paths) {
+		const files = [];
+		for (const p of paths) {
+			if (p.endsWith(".js") || p.endsWith(".ts")) {
+				files.push(p);
+				continue;
+			}
+			files.push(...await glob$1(p));
+		}
+		return files;
+	}
+	async resolvePath(filePath) {
+		try {
+			const mod = await import(filePath);
+			return new (mod.default ?? mod.Seeder)();
+		} catch {
+			return null;
+		}
+	}
+	async run(paths, connection) {
+		const files = await this.getSeederFiles(paths);
+		const conn = this.resolveConnection(connection);
+		for (const file of files) {
+			const seeder = await this.resolvePath(file);
+			if (seeder && typeof seeder.run === "function") await seeder.run(conn);
+		}
+	}
+};
+var runner_default = SeederRunner;
+
 //#endregion
 //#region src/inspector/dialects/sqlite.ts
 function parseDefaultValue(value) {
@@ -4828,7 +4876,7 @@ var SQLite = class {
 	* List all existing tables in the current schema/database
 	*/
 	async tables() {
-		return (await this.knex.select("name").from("sqlite_master").whereRaw("type = 'table' AND name NOT LIKE 'sqlite_%'")).map(({ name: name$1 }) => name$1);
+		return (await this.knex.select("name").from("sqlite_master").whereRaw("type = 'table' AND name NOT LIKE 'sqlite_%'")).map(({ name }) => name);
 	}
 	async tableInfo(table) {
 		const query = this.knex.select("name", "sql").from("sqlite_master").where({ type: "table" }).andWhereRaw("name NOT LIKE 'sqlite_%'");
@@ -4859,12 +4907,11 @@ var SQLite = class {
 			column: column.name
 		}));
 		const tables = await this.tables();
-		const columnsPerTable = await Promise.all(tables.map(async (table$1) => await this.columns(table$1)));
-		return flatten(columnsPerTable);
+		return flatten(await Promise.all(tables.map(async (table$1) => await this.columns(table$1))));
 	}
 	async columnInfo(table, column) {
 		const getColumnsForTable = async (table$1) => {
-			const tablesWithAutoIncrementPrimaryKeys = (await this.knex.select("name").from("sqlite_master").whereRaw("sql LIKE '%AUTOINCREMENT%'")).map(({ name: name$1 }) => name$1);
+			const tablesWithAutoIncrementPrimaryKeys = (await this.knex.select("name").from("sqlite_master").whereRaw("sql LIKE '%AUTOINCREMENT%'")).map(({ name }) => name);
 			const columns = await this.knex.raw("PRAGMA table_xinfo(??)", table$1);
 			const foreignKeys = await this.knex.raw("PRAGMA foreign_key_list(??)", table$1);
 			const indexList = await this.knex.raw("PRAGMA index_list(??)", table$1);
@@ -4895,8 +4942,7 @@ var SQLite = class {
 		};
 		if (!table) {
 			const tables = await this.tables();
-			const columnsPerTable = await Promise.all(tables.map(async (table$1) => await getColumnsForTable(table$1)));
-			return flatten(columnsPerTable);
+			return flatten(await Promise.all(tables.map(async (table$1) => await getColumnsForTable(table$1))));
 		}
 		if (table && !column) return await getColumnsForTable(table);
 		return (await getColumnsForTable(table)).find((columnInfo) => columnInfo.name === column);
@@ -4927,8 +4973,7 @@ var SQLite = class {
 			constraint_name: null
 		}));
 		const tables = await this.tables();
-		const keysPerTable = await Promise.all(tables.map(async (table$1) => await this.foreignKeys(table$1)));
-		return flatten(keysPerTable);
+		return flatten(await Promise.all(tables.map(async (table$1) => await this.foreignKeys(table$1))));
 	}
 	async uniqueConstraints(table) {
 		if (table) {
@@ -4944,8 +4989,7 @@ var SQLite = class {
 			});
 		}
 		const tables = await this.tables();
-		const constraintsPerTable = await Promise.all(tables.map(async (table$1) => await this.uniqueConstraints(table$1)));
-		return flatten(constraintsPerTable);
+		return flatten(await Promise.all(tables.map(async (table$1) => await this.uniqueConstraints(table$1))));
 	}
 };
 
@@ -4985,9 +5029,9 @@ var SchemaInspector = class {
 //#endregion
 //#region src/migrations/migrator.ts
 async function glob(folderPath) {
-	const files$1 = await fs.readdir(folderPath);
+	const files = await fs.readdir(folderPath);
 	const allFiles = [];
-	for (const file of files$1) {
+	for (const file of files) {
 		const filePath = `${folderPath}/${file}`;
 		const stats = await fs.stat(filePath);
 		if (stats.isFile()) allFiles.push(filePath);
@@ -5006,21 +5050,21 @@ var Migrator = class {
 	connection;
 	paths = [];
 	output = null;
-	constructor(repository$1, resolver = null, files$1 = null, dispatcher = null) {
-		this.repository = repository$1;
-		this.files = files$1;
+	constructor(repository, resolver = null, files = null, dispatcher = null) {
+		this.repository = repository;
+		this.files = files;
 		this.resolver = resolver;
 		this.events = dispatcher;
 	}
 	async run(paths = [], options = {}) {
-		const files$1 = await this.getMigrationFiles(paths);
+		const files = await this.getMigrationFiles(paths);
 		const ran = await this.repository.getRan();
-		const migrations = this.pendingMigrations(files$1, ran);
+		const migrations = this.pendingMigrations(files, ran);
 		await this.runPending(migrations, options);
 		return migrations;
 	}
-	pendingMigrations(files$1, ran) {
-		return Object.values(files$1).filter((file) => !ran.includes(this.getMigrationName(file)));
+	pendingMigrations(files, ran) {
+		return Object.values(files).filter((file) => !ran.includes(this.getMigrationName(file)));
 	}
 	async runPending(migrations, options = {}) {
 		if (migrations.length === 0 && !options.quiet) {
@@ -5038,14 +5082,14 @@ var Migrator = class {
 	}
 	async runUp(file, batch, _pretend) {
 		const migration = await this.resolvePath(file);
-		const name$1 = this.getMigrationName(file);
-		await TaskManager.taskRunner(name$1, () => this.runMigration(migration, "up"));
-		await this.repository.log(name$1, batch);
+		const name = this.getMigrationName(file);
+		await TaskManager.taskRunner(name, () => this.runMigration(migration, "up"));
+		await this.repository.log(name, batch);
 	}
 	async runDown(file, migration, _pretend) {
 		const instance = await this.resolvePath(file);
-		const name$1 = this.getMigrationName(file);
-		await TaskManager.taskRunner(name$1, () => this.runMigration(instance, "down"));
+		const name = this.getMigrationName(file);
+		await TaskManager.taskRunner(name, () => this.runMigration(instance, "down"));
 		await this.repository.delete(migration);
 	}
 	async rollback(paths = [], options = {}) {
@@ -5063,10 +5107,10 @@ var Migrator = class {
 	}
 	async rollbackMigrations(migrations, paths, options) {
 		const rolledBack = [];
-		const files$1 = await this.getMigrationFiles(paths);
+		const files = await this.getMigrationFiles(paths);
 		Logger.info("INFO: Rolling back migrations...");
 		for (const migration of migrations) {
-			const file = files$1[migration.migration];
+			const file = files[migration.migration];
 			if (!file) {
 				Logger.twoColumnDetail(Logger.parse([[migration.migration, "green"]], "", false), Logger.parse([["Migration not found", "yellow"]], "", false));
 				continue;
@@ -5129,15 +5173,15 @@ var Migrator = class {
 		return migrationName.split("_").slice(4).map((str) => str.charAt(0).toUpperCase() + str.slice(1)).join("");
 	}
 	async getMigrationFiles(paths) {
-		const files$1 = [];
+		const files = [];
 		for (const p of paths) {
 			if (p.endsWith(".js") || p.endsWith(".ts")) {
-				files$1.push(p);
+				files.push(p);
 				continue;
 			}
-			files$1.push(...await glob(p));
+			files.push(...await glob(p));
 		}
-		return files$1.filter(Boolean).reduce((result, file) => {
+		return files.filter(Boolean).reduce((result, file) => {
 			result[this.getMigrationName(file)] = file;
 			return result;
 		}, {});
@@ -5292,21 +5336,19 @@ var Migrate = class {
 		const getAllMigrationFiles = async () => {
 			return await migrator.getMigrationFiles(await Utils.getMigrationPaths(this.basePath ?? process.cwd(), migrator, config$1.migrations.path, options.path));
 		};
-		async function getStatusFor(ran$1, batches$1) {
-			const files$1 = await getAllMigrationFiles();
-			return Object.values(files$1).map((migration) => {
+		async function getStatusFor(ran, batches) {
+			const files = await getAllMigrationFiles();
+			return Object.values(files).map((migration) => {
 				const migrationName = migrator.getMigrationName(migration);
 				return {
 					name: migrationName,
-					ran: ran$1.includes(migrationName),
-					batch: ran$1.includes(migrationName) ? batches$1[migrationName] : null
+					ran: ran.includes(migrationName),
+					batch: ran.includes(migrationName) ? batches[migrationName] : null
 				};
 			});
 		}
 		if (!await migrator.repositoryExists()) this.callback("ERROR: Migration table does not exist.", "error");
-		const ran = await migrator.repository.getRan();
-		const batches = await migrator.getRepository().getMigrationBatches();
-		const migrations = await getStatusFor(ran, batches);
+		const migrations = await getStatusFor(await migrator.repository.getRan(), await migrator.getRepository().getMigrationBatches());
 		if (destroyAll) await arquebus$1.destroyAll();
 		return migrations;
 	}
@@ -5321,15 +5363,13 @@ var Migrate = class {
 		const table = (config$1 === null || config$1 === void 0 || (_config$migrations = config$1.migrations) === null || _config$migrations === void 0 ? void 0 : _config$migrations.table) || "migrations";
 		if (config$1.skipConnection !== true) {
 			arquebus_default.addConnection(config$1, "default");
-			Object.entries(config$1.connections || {}).forEach(([name$1, connection]) => {
-				arquebus_default.addConnection(connection, name$1);
+			Object.entries(config$1.connections || {}).forEach(([name, connection]) => {
+				arquebus_default.addConnection(connection, name);
 			});
 		}
-		const repository$1 = new MigrationRepository(arquebus_default, table);
-		const migrator = new migrator_default(repository$1, arquebus_default);
 		return {
 			arquebus: arquebus_default,
-			migrator
+			migrator: new migrator_default(new MigrationRepository(arquebus_default, table), arquebus_default)
 		};
 	}
 };
@@ -5338,9 +5378,9 @@ var Migrate = class {
 //#region src/migrations/migration-creator.ts
 var MigrationCreator = class {
 	postCreate = [];
-	constructor(customStubPath, type$1 = "js") {
+	constructor(customStubPath, type = "js") {
 		this.customStubPath = customStubPath;
-		this.type = type$1;
+		this.type = type;
 	}
 	/**
 	* Create a new migration file
@@ -5351,9 +5391,9 @@ var MigrationCreator = class {
 	* @param create
 	* @returns
 	*/
-	async create(name$1, dir, table, create = false) {
+	async create(name, dir, table, create = false) {
 		const stub = await this.getStub(table, create);
-		const filePath = this.getPath(name$1, dir);
+		const filePath = this.getPath(name, dir);
 		await this.ensureDirectoryExists(path.dirname(filePath));
 		await writeFile(filePath, this.populateStub(stub, table));
 		await this.firePostCreateHooks(table, filePath);
@@ -5394,12 +5434,12 @@ var MigrationCreator = class {
 		if (table) stub = stub.replace(/DummyTable|{{\s*table\s*}}/g, table);
 		return stub;
 	}
-	getClassName(name$1) {
-		return name$1.replace(/_+([a-z])/g, (match, char) => char.toUpperCase());
+	getClassName(name) {
+		return name.replace(/_+([a-z])/g, (match, char) => char.toUpperCase());
 	}
-	getPath(name$1, dir) {
+	getPath(name, dir) {
 		const datePrefix = dayjs().format("YYYY_MM_DD_HHmmss");
-		return path.join(dir, `${datePrefix}_${name$1}.${this.type}`);
+		return path.join(dir, `${datePrefix}_${name}.${this.type}`);
 	}
 	async firePostCreateHooks(table, filePath) {
 		for (const callback of this.postCreate) await callback(table, filePath);
@@ -5423,224 +5463,7 @@ var MigrationCreator = class {
 
 //#endregion
 //#region package.json
-var name = "@h3ravel/arquebus";
-var version = "0.6.6";
-var packageManager = "pnpm@10.14.0";
-var description = "Arquebus ORM is a Beautiful, expressive ORM inspired by Laravel's Eloquent, designed for TypeScript applications and for the H3ravel Framework.";
-var homepage = "https://h3ravel.toneflix.net/arquebus";
-var bin = { "arquebus": "./bin/index.js" };
-var publishConfig = { "access": "public" };
-var main = "./dist/index.cjs";
-var module = "./dist/index.js";
-var type = "module";
-var types = "./dist/index.d.ts";
-var files = [
-	"dist",
-	"bin",
-	"types"
-];
-var exports = {
-	".": {
-		"cli": {
-			"import": {
-				"types": "./bin/index.d.ts",
-				"default": "./bin/index.js"
-			},
-			"require": {
-				"types": "./bin/index.d.cts",
-				"default": "./bin/index.cjs"
-			}
-		},
-		"worker": {
-			"import": {
-				"types": "./dist/index.d.ts",
-				"default": "./dist/index.js"
-			},
-			"require": {
-				"types": "./dist/index.d.cts",
-				"default": "./dist/index.cjs"
-			}
-		},
-		"node": {
-			"import": {
-				"types": "./dist/index.d.ts",
-				"default": "./dist/index.js"
-			},
-			"require": {
-				"types": "./dist/index.d.cts",
-				"default": "./dist/index.cjs"
-			}
-		},
-		"browser": {
-			"import": {
-				"types": "./dist/browser/index.d.ts",
-				"default": "./dist/browser/index.js"
-			},
-			"require": {
-				"types": "./dist/browser/index.d.cts",
-				"default": "./dist/browser/index.cjs"
-			}
-		},
-		"default": {
-			"import": {
-				"types": "./dist/index.d.ts",
-				"default": "./dist/index.js"
-			},
-			"require": {
-				"types": "./dist/index.d.cts",
-				"default": "./dist/index.cjs"
-			}
-		}
-	},
-	"./migrations": {
-		"import": {
-			"types": "./dist/migrations/index.d.ts",
-			"default": "./dist/migrations/index.js"
-		},
-		"require": {
-			"types": "./dist/migrations/index.d.cts",
-			"default": "./dist/migrations/index.cjs"
-		}
-	},
-	"./inspector": {
-		"import": {
-			"types": "./dist/inspector/index.d.ts",
-			"default": "./dist/inspector/index.js"
-		},
-		"require": {
-			"types": "./dist/inspector/index.d.cts",
-			"default": "./dist/inspector/index.cjs"
-		}
-	},
-	"./seeders": {
-		"import": {
-			"types": "./dist/seeders/index.d.ts",
-			"default": "./dist/seeders/index.js"
-		},
-		"require": {
-			"types": "./dist/seeders/index.d.cts",
-			"default": "./dist/seeders/index.cjs"
-		}
-	},
-	"./browser": {
-		"import": {
-			"types": "./dist/browser/index.d.ts",
-			"default": "./dist/browser/index.js"
-		},
-		"require": {
-			"types": "./dist/browser/index.d.cts",
-			"default": "./dist/browser/index.cjs"
-		}
-	},
-	"./package.json": "./package.json",
-	"./types": "./types/index.ts"
-};
-var repository = {
-	"type": "git",
-	"url": "https://github.com/h3ravel/arquebus.git"
-};
-var engines = {
-	"node": ">=14",
-	"pnpm": ">=4"
-};
-var scripts = {
-	"build": "tsdown",
-	"lint": "eslint . --ext .ts",
-	"barrel": "barrelize >/dev/null",
-	"postinstall": "pnpm barrel",
-	"cmd": "cross-env TEST=true tsx --experimental-specifier-resolution=node src/cli",
-	"cmd:watch": "cross-env TEST=true tsx watch --experimental-specifier-resolution=node src/cli",
-	"test": "cross-env vitest --project generic",
-	"test:mysql": "cross-env DB=mysql vitest --project node",
-	"test:postgres": "cross-env DB=postgres vitest --project node",
-	"test:sqlite": "cross-env DB=sqlite vitest --project node",
-	"test:browser": "vitest --project browser",
-	"release:patch": "pnpm build && git add . && git commit -m \"version: bump version\" && pnpm version patch && pnpm publish --tag latest"
-};
-var husky = { "hooks": { "pre-commit": "lint-staged" } };
-var lint_staged = { "*.{js,json}": ["prettier --write", "git add"] };
-var dependencies = {
-	"@h3ravel/shared": "^0.21.0",
-	"@h3ravel/support": "^0.12.0",
-	"barrelize": "^1.6.4",
-	"chalk": "^5.6.2",
-	"collect.js": "^4.36.1",
-	"commander": "^14.0.1",
-	"cross-env": "^10.0.0",
-	"dayjs": "^1.11.18",
-	"dotenv": "^17.2.2",
-	"escalade": "^3.2.0",
-	"husky": "^9.1.7",
-	"knex": "^3.1.0",
-	"lint-staged": "^16.2.0",
-	"mysql2": "^3.15.0",
-	"pg": "^8.16.3",
-	"pluralize": "^8.0.0",
-	"radashi": "^12.6.2",
-	"resolve-from": "^5.0.0",
-	"tedious": "^19.0.0"
-};
-var devDependencies = {
-	"@eslint/js": "^9.36.0",
-	"@types/node": "^24.5.2",
-	"@types/pluralize": "^0.0.33",
-	"@typescript-eslint/eslint-plugin": "^8.44.0",
-	"@typescript-eslint/parser": "^8.44.0",
-	"@vitest/coverage-v8": "^3.2.4",
-	"eslint": "^9.36.0",
-	"jsdom": "^26.1.0",
-	"prettier": "^3.6.2",
-	"sqlite3": "5.1.7",
-	"terser": "^5.44.0",
-	"ts-node": "^10.9.2",
-	"tsdown": "^0.15.4",
-	"tsx": "^4.20.5",
-	"typescript": "^5.9.2",
-	"typescript-eslint": "^8.44.0",
-	"vite-tsconfig-paths": "^5.1.4",
-	"vitest": "^3.2.4"
-};
-var keywords = [
-	"arquebus",
-	"ORM",
-	"mysql",
-	"mariadb",
-	"sqlite",
-	"postgresql",
-	"postgres",
-	"pg",
-	"mssql",
-	"active record"
-];
-var pnpm = { "onlyBuiltDependencies": ["sqlite3"] };
-var readmeFilename = "README.md";
-var license = "MIT";
-var package_default = {
-	name,
-	version,
-	packageManager,
-	description,
-	homepage,
-	bin,
-	publishConfig,
-	main,
-	module,
-	type,
-	types,
-	files,
-	exports,
-	repository,
-	engines,
-	scripts,
-	husky,
-	"lint-staged": lint_staged,
-	dependencies,
-	devDependencies,
-	keywords,
-	pnpm,
-	readmeFilename,
-	license
-};
+var version = "0.6.7";
 
 //#endregion
 //#region src/cli/cli.ts
@@ -5697,26 +5520,26 @@ var Cli = class Cli {
 		return this;
 	}
 	async run() {
-		const cliVersion = ["Arquebus CLI version:", Logger.log(package_default.version, "green", false)].join(" ");
+		const cliVersion = ["Arquebus CLI version:", Logger.log(version, "green", false)].join(" ");
 		const localVersion = ["Arquebus Local version:", Logger.log(this.modulePackage.version || "None", "green", false)].join(" ");
 		program.name("arquebus").version(`${cliVersion}\n${localVersion}`);
-		program.command("init").description("Create a fresh Arquebus config.").addArgument(new Argument("[type]", "Type of config to generate.").choices(["js", "ts"]).default("js", "generates a js config")).action(async (type$1) => {
+		program.command("init").description("Create a fresh Arquebus config.").addArgument(new Argument("[type]", "Type of config to generate.").choices(["js", "ts"]).default("js", "generates a js config")).action(async (type) => {
 			if (!this.modulePath) this.output.error(["ERROR: No local arquebus install found", " Try running: npm install arquebus --save"]);
 			if (this.configPath) this.output.error(`ERROR: ${this.configPath} already exists`);
 			try {
-				const stubPath = `./arquebus.config.${type$1}`;
-				const code = await readFile(path.join(this.modulePath, `/src/stubs/arquebus.config-${type$1}.stub`), { encoding: "utf8" });
+				const stubPath = `./arquebus.config.${type}`;
+				const code = await readFile(path.join(this.modulePath, `/src/stubs/arquebus.config-${type}.stub`), { encoding: "utf8" });
 				await writeFile(path.join(this.cwd, stubPath), code);
 				this.output.success(`Initialized: Arquebus has been initialized as ${stubPath}`);
 			} catch (e) {
 				this.output.error("ERROR: " + e);
 			}
 		});
-		program.command("make:migration <name>").description("Create a new migration file.").addOption(new Option("-l, --type [string]", "Type of migration file to generate.").choices(["js", "ts"]).default("js", "generates a js migration file")).option("-t, --table [string]", "The table to migrate").option("-c, --create [string]", "The table to be created").option("-p, --path [path]", "The path to the migrations directory.").action(async (name$1, opts) => {
+		program.command("make:migration <name>").description("Create a new migration file.").addOption(new Option("-l, --type [string]", "Type of migration file to generate.").choices(["js", "ts"]).default("js", "generates a js migration file")).option("-t, --table [string]", "The table to migrate").option("-c, --create [string]", "The table to be created").option("-p, --path [path]", "The path to the migrations directory.").action(async (name, opts) => {
 			if (!this.configPath) this.terminateNotFound();
 			try {
 				var _this$config$migratio3;
-				name$1 = snake(name$1);
+				name = snake(name);
 				const migrationPath = path.join(this.cwd, opts.path ?? ((_this$config$migratio3 = this.config.migrations) === null || _this$config$migratio3 === void 0 ? void 0 : _this$config$migratio3.path) ?? "./migrations");
 				let table = opts.table;
 				let create = Boolean(opts.create) && opts.create !== "";
@@ -5725,12 +5548,12 @@ var Cli = class Cli {
 					create = true;
 				}
 				if (!table) {
-					const guessed = TableGuesser.guess(name$1);
+					const guessed = TableGuesser.guess(name);
 					table = guessed[0];
 					create = !!guessed[1];
 				}
 				this.output.info("INFO: Creating Migration");
-				const fileName = await new MigrationCreator(void 0, opts.type).create(name$1, migrationPath, table, create);
+				const fileName = await new MigrationCreator(void 0, opts.type).create(name, migrationPath, table, create);
 				this.output.success(`INFO: Migration Created \n ${Logger.log(path.basename(fileName), "gray", false)}`, true);
 			} catch (e) {
 				this.output.error("ERROR: " + e);
@@ -5865,8 +5688,8 @@ var Cli = class Cli {
 					...this.config,
 					skipConnection: false
 				});
-				const { SeederRunner } = await import("./seeders-8GJzfIIN.js");
-				const runner = new SeederRunner(arquebus$1);
+				const { SeederRunner: SeederRunner$1 } = await import("./seeders-C0schOjT.mjs");
+				const runner = new SeederRunner$1(arquebus$1);
 				const seederPath = path.join(basePath, ((_this$config$seeders = this.config.seeders) === null || _this$config$seeders === void 0 ? void 0 : _this$config$seeders.path) ?? "./seeders");
 				await runner.setConnection(this.config.client).run([seederPath]);
 				this.output.success("Seeders executed successfully.");
@@ -5877,16 +5700,15 @@ var Cli = class Cli {
 		/**
 		* Create a new seeder file
 		*/
-		program.command("make:seeder <name>").description("Create a new Seeder file.").addOption(new Option("-l, --type [string]", "Type of seeder file to generate.").choices(["js", "ts"]).default("js", "generates a js seeder file")).option("--force", "Force creation if seeder already exists.", false).option("-p, --path [path]", "The path to the seeders directory.").action(async (name$1, opts) => {
+		program.command("make:seeder <name>").description("Create a new Seeder file.").addOption(new Option("-l, --type [string]", "Type of seeder file to generate.").choices(["js", "ts"]).default("js", "generates a js seeder file")).option("--force", "Force creation if seeder already exists.", false).option("-p, --path [path]", "The path to the seeders directory.").action(async (name, opts) => {
 			var _this$config$seeders2;
 			if (!this.configPath) this.terminateNotFound();
-			const seederPath = path.join(this.cwd, opts.path ?? ((_this$config$seeders2 = this.config.seeders) === null || _this$config$seeders2 === void 0 ? void 0 : _this$config$seeders2.path) ?? "./seeders", Str.of(name$1).snake("-") + "." + opts.type);
+			const seederPath = path.join(this.cwd, opts.path ?? ((_this$config$seeders2 = this.config.seeders) === null || _this$config$seeders2 === void 0 ? void 0 : _this$config$seeders2.path) ?? "./seeders", Str.of(name).snake("-") + "." + opts.type);
 			try {
 				if (!opts.force && await FileSystem.fileExists(seederPath)) this.output.error("ERROR: Seeder already exists.");
 				await mkdir(path.dirname(seederPath), { recursive: true });
-				const stubPath = path.join(this.modulePath, `src/stubs/seeder-${opts.type}.stub`);
-				let stub = await readFile(stubPath, "utf-8");
-				stub = stub.replace(/{{ name }}/g, name$1);
+				let stub = await readFile(path.join(this.modulePath, `src/stubs/seeder-${opts.type}.stub`), "utf-8");
+				stub = stub.replace(/{{ name }}/g, name);
 				await writeFile(seederPath, stub);
 				this.output.split("INFO: Created Seeder", path.relative(this.cwd, seederPath));
 			} catch (e) {
@@ -5896,16 +5718,15 @@ var Cli = class Cli {
 		/**
 		* Create a new model file
 		*/
-		program.command("make:model <name>").description("Create a new Model file.").addOption(new Option("-l, --type [string]", "Type of migration file to generate.").choices(["js", "ts"]).default("js", "generates a js migration file")).option("--force", "Force creation if model already exists.", false).option("-p, --path [path]", "The path to the models directory.").action(async (name$1, opts) => {
+		program.command("make:model <name>").description("Create a new Model file.").addOption(new Option("-l, --type [string]", "Type of migration file to generate.").choices(["js", "ts"]).default("js", "generates a js migration file")).option("--force", "Force creation if model already exists.", false).option("-p, --path [path]", "The path to the models directory.").action(async (name, opts) => {
 			var _this$config$models;
 			if (!this.configPath) this.terminateNotFound();
-			const modelPath = path.join(this.cwd, opts.path ?? ((_this$config$models = this.config.models) === null || _this$config$models === void 0 ? void 0 : _this$config$models.path) ?? "./models", name$1.toLowerCase() + "." + opts.type);
+			const modelPath = path.join(this.cwd, opts.path ?? ((_this$config$models = this.config.models) === null || _this$config$models === void 0 ? void 0 : _this$config$models.path) ?? "./models", name.toLowerCase() + "." + opts.type);
 			try {
 				if (!opts.force && await FileSystem.fileExists(modelPath)) this.output.error("ERROR: Model already exists.");
 				await mkdir(path.dirname(modelPath), { recursive: true });
-				const stubPath = path.join(this.modulePath, `src/stubs/model-${opts.type}.stub`);
-				let stub = await readFile(stubPath, "utf-8");
-				stub = stub.replace(/{{ name }}/g, name$1);
+				let stub = await readFile(path.join(this.modulePath, `src/stubs/model-${opts.type}.stub`), "utf-8");
+				stub = stub.replace(/{{ name }}/g, name);
 				await writeFile(modelPath, stub);
 				this.output.success(`Created Model: ${modelPath}`);
 			} catch (e) {
@@ -5922,4 +5743,4 @@ var Cli = class Cli {
 Cli.init();
 
 //#endregion
-export {  };
+export { runner_default as t };