arkormx 1.3.0 → 1.3.2

package/dist/cli.mjs

@@ -5,13 +5,14 @@ import { spawnSync } from "node:child_process";
 import { str } from "@h3ravel/support";
 import path, { dirname as dirname$1, extname as extname$1, join as join$1, relative } from "path";
 import { copyFileSync, existsSync as existsSync$1, mkdirSync as mkdirSync$1, readFileSync as readFileSync$1, readdirSync as readdirSync$1, rmSync as rmSync$1, writeFileSync as writeFileSync$1 } from "fs";
-import { fileURLToPath, pathToFileURL } from "url";
 import { AsyncLocalStorage } from "async_hooks";
+import { createJiti } from "@rexxars/jiti";
+import { pathToFileURL } from "node:url";
 import { createRequire } from "module";
+import { fileURLToPath } from "url";
 import { Logger } from "@h3ravel/shared";
 import { Command, Kernel } from "@h3ravel/musket";
 import { createHash } from "node:crypto";
-import { pathToFileURL as pathToFileURL$1 } from "node:url";
 
 //#region src/Exceptions/ArkormException.ts
 var ArkormException = class extends Error {
@@ -1413,6 +1414,18 @@ const applyMigrationRollbackToPrismaSchema = async (migration, options = {}) =>
 	};
 };
 
+//#endregion
+//#region src/helpers/runtime-module-loader.ts
+var RuntimeModuleLoader = class {
+	static async load(filePath) {
+		const resolvedPath = resolve(filePath);
+		return await createJiti(pathToFileURL(resolvedPath).href, {
+			interopDefault: false,
+			tsconfigPaths: true
+		}).import(resolvedPath);
+	}
+};
+
 //#endregion
 //#region src/helpers/runtime-config.ts
 const resolveDefaultStubsPath = () => {
@@ -1516,7 +1529,7 @@ const resolveAndApplyConfig = (imported) => {
 * @returns A promise that resolves to the imported configuration module.   
 */
 const importConfigFile = (configPath) => {
-	return import(`${pathToFileURL(configPath).href}?arkorm_runtime=${Date.now()}`);
+	return RuntimeModuleLoader.load(configPath);
 };
 const loadRuntimeConfigSync = () => {
 	const require = createRequire(import.meta.url);
@@ -1870,10 +1883,225 @@ var CliApp = class {
 		if (value === "String") return "string";
 		if (value === "Boolean") return "boolean";
 		if (value === "DateTime") return "Date";
-		if (value === "Json") return "Record<string, unknown>";
+		if (value === "Json") return "Record<string, unknown> | unknown[]";
 		if (value === "Bytes") return "Buffer";
 		return "unknown";
 	}
+	splitTopLevel(value, delimiter) {
+		const parts = [];
+		let start = 0;
+		let angleDepth = 0;
+		let parenthesisDepth = 0;
+		let quote = null;
+		for (let index = 0; index < value.length; index += 1) {
+			const character = value[index];
+			const previous = index > 0 ? value[index - 1] : "";
+			if (quote) {
+				if (character === quote && previous !== "\\") quote = null;
+				continue;
+			}
+			if (character === "'" || character === "\"") {
+				quote = character;
+				continue;
+			}
+			if (character === "<") {
+				angleDepth += 1;
+				continue;
+			}
+			if (character === ">") {
+				angleDepth = Math.max(0, angleDepth - 1);
+				continue;
+			}
+			if (character === "(") {
+				parenthesisDepth += 1;
+				continue;
+			}
+			if (character === ")") {
+				parenthesisDepth = Math.max(0, parenthesisDepth - 1);
+				continue;
+			}
+			if (character === delimiter && angleDepth === 0 && parenthesisDepth === 0) {
+				parts.push(value.slice(start, index).trim());
+				start = index + 1;
+			}
+		}
+		parts.push(value.slice(start).trim());
+		return parts.filter(Boolean);
+	}
+	hasWrappedParentheses(value) {
+		if (!value.startsWith("(") || !value.endsWith(")")) return false;
+		let depth = 0;
+		let quote = null;
+		for (let index = 0; index < value.length; index += 1) {
+			const character = value[index];
+			const previous = index > 0 ? value[index - 1] : "";
+			if (quote) {
+				if (character === quote && previous !== "\\") quote = null;
+				continue;
+			}
+			if (character === "'" || character === "\"") {
+				quote = character;
+				continue;
+			}
+			if (character === "(") depth += 1;
+			if (character === ")") {
+				depth -= 1;
+				if (depth === 0 && index < value.length - 1) return false;
+			}
+		}
+		return depth === 0;
+	}
+	stripWrappedParentheses(value) {
+		let nextValue = value.trim();
+		while (this.hasWrappedParentheses(nextValue)) nextValue = nextValue.slice(1, -1).trim();
+		return nextValue;
+	}
+	parseDeclarationType(value) {
+		const trimmed = this.stripWrappedParentheses(value.trim());
+		if (!trimmed) return null;
+		const unionParts = this.splitTopLevel(trimmed, "|");
+		if (unionParts.length > 1) {
+			const types = unionParts.map((part) => this.parseDeclarationType(part)).filter((part) => part !== null);
+			if (types.length !== unionParts.length) return null;
+			return {
+				kind: "union",
+				types: types.flatMap((type) => type.kind === "union" ? type.types : [type])
+			};
+		}
+		if (trimmed.endsWith("[]")) {
+			const element = this.parseDeclarationType(trimmed.slice(0, -2));
+			if (!element) return null;
+			return {
+				kind: "array",
+				element
+			};
+		}
+		const arrayMatch = trimmed.match(/^(Array|ReadonlyArray)<([\s\S]+)>$/);
+		if (arrayMatch) {
+			const element = this.parseDeclarationType(arrayMatch[2]);
+			if (!element) return null;
+			return {
+				kind: "array",
+				element
+			};
+		}
+		if (trimmed === "null") return { kind: "null" };
+		if (trimmed.startsWith("'") && trimmed.endsWith("'") || trimmed.startsWith("\"") && trimmed.endsWith("\"")) return {
+			kind: "string-literal",
+			value: trimmed.slice(1, -1)
+		};
+		if (trimmed === "Record<string, unknown>") return {
+			kind: "named",
+			name: trimmed
+		};
+		if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(trimmed)) return {
+			kind: "named",
+			name: trimmed
+		};
+		return null;
+	}
+	expandUnion(node) {
+		return node.kind === "union" ? node.types : [node];
+	}
+	isEnumTypeName(value, enums) {
+		return enums.has(value);
+	}
+	isDeclarationNodeAssignable(actual, expected, enums) {
+		if (expected.kind === "named") {
+			if (expected.name === "unknown") return true;
+			if (actual.kind === "named") {
+				if (actual.name === expected.name) return true;
+				if (expected.name === "string" && this.isEnumTypeName(actual.name, enums)) return true;
+			}
+			if (actual.kind === "string-literal") {
+				if (expected.name === "string") return true;
+				if (enums.get(expected.name)?.includes(actual.value)) return true;
+			}
+			return false;
+		}
+		if (expected.kind === "array") return actual.kind === "array" && this.isDeclarationAssignable(actual.element, expected.element, enums);
+		if (expected.kind === "null") return actual.kind === "null";
+		if (expected.kind === "string-literal") return actual.kind === "string-literal" && actual.value === expected.value;
+		return false;
+	}
+	isDeclarationAssignable(actual, expected, enums) {
+		const actualTypes = this.expandUnion(actual);
+		const expectedTypes = this.expandUnion(expected);
+		return actualTypes.every((actualType) => {
+			return expectedTypes.some((expectedType) => {
+				return this.isDeclarationNodeAssignable(actualType, expectedType, enums);
+			});
+		});
+	}
+	isCompatibleDeclarationType(actualType, expectedType, enums) {
+		const actual = this.parseDeclarationType(actualType);
+		const expected = this.parseDeclarationType(expectedType);
+		if (!actual || !expected) return actualType.replace(/\s+/g, " ").trim() === expectedType.replace(/\s+/g, " ").trim();
+		return this.isDeclarationAssignable(actual, expected, enums);
+	}
+	collectEnumReferencesFromNode(node, enums, collected) {
+		if (node.kind === "named" && enums.has(node.name)) {
+			collected.add(node.name);
+			return;
+		}
+		if (node.kind === "array") {
+			this.collectEnumReferencesFromNode(node.element, enums, collected);
+			return;
+		}
+		if (node.kind === "union") node.types.forEach((type) => this.collectEnumReferencesFromNode(type, enums, collected));
+	}
+	collectEnumReferences(type, enums) {
+		const parsed = this.parseDeclarationType(type);
+		if (!parsed) return [];
+		const collected = /* @__PURE__ */ new Set();
+		this.collectEnumReferencesFromNode(parsed, enums, collected);
+		return [...collected].sort((left, right) => left.localeCompare(right));
+	}
+	syncPrismaEnumImports(modelSource, enumTypes) {
+		if (enumTypes.length === 0) return modelSource;
+		const importRegex = /^import\s+type\s+\{([^}]+)\}\s+from\s+['"]@prisma\/client['"]\s*;?$/m;
+		const existingImport = modelSource.match(importRegex);
+		if (existingImport) {
+			const existingTypes = existingImport[1].split(",").map((value) => value.trim()).filter(Boolean);
+			const mergedTypes = [...new Set([...existingTypes, ...enumTypes])].sort((left, right) => left.localeCompare(right));
+			return modelSource.replace(importRegex, `import type { ${mergedTypes.join(", ")} } from '@prisma/client'`);
+		}
+		const lines = modelSource.split("\n");
+		let insertionIndex = 0;
+		while (insertionIndex < lines.length && lines[insertionIndex].trim().startsWith("import ")) insertionIndex += 1;
+		lines.splice(insertionIndex, 0, `import type { ${enumTypes.join(", ")} } from '@prisma/client'`);
+		return lines.join("\n");
+	}
+	/**
+	* Parse Prisma enum definitions from a schema and return their member names.
+	*
+	* @param schema The Prisma schema source.
+	* @returns      A map of enum names to their declared member names.
+	*/
+	parsePrismaEnums(schema) {
+		const enums = /* @__PURE__ */ new Map();
+		for (const match of schema.matchAll(PRISMA_ENUM_REGEX)) {
+			const enumName = match[1];
+			const values = match[0].split("\n").slice(1, -1).map((line) => line.trim()).filter((line) => Boolean(line) && !line.startsWith("//")).map((line) => {
+				return line.match(/^([A-Za-z][A-Za-z0-9_]*)\b/)?.[1];
+			}).filter((value) => Boolean(value));
+			enums.set(enumName, values);
+		}
+		return enums;
+	}
+	/**
+	* Resolve the generated TypeScript declaration type for a Prisma field.
+	*
+	* @param fieldType  The Prisma field type token.
+	* @param isList     Whether the field is declared as a Prisma list.
+	* @param enums      Known Prisma enum definitions.
+	* @returns          The declaration type to emit, or null when unsupported.
+	*/
+	prismaFieldTypeToTs(fieldType, isList, enums) {
+		const baseType = enums.has(fieldType) ? fieldType : this.prismaTypeToTs(fieldType);
+		if (baseType === "unknown" && !enums.has(fieldType)) return null;
+		return isList ? `Array<${baseType}>` : baseType;
+	}
 	/**
 	* Parse the Prisma schema to extract model definitions and their fields, focusing 
 	* on scalar types.
@@ -1883,6 +2111,7 @@ var CliApp = class {
 	*/
 	parsePrismaModels(schema) {
 		const models = [];
+		const enumDefinitions = this.parsePrismaEnums(schema);
 		const modelRegex = /model\s+(\w+)\s*\{([\s\S]*?)\n\}/g;
 		const scalarTypes = new Set([
 			"Int",
@@ -1903,14 +2132,16 @@ var CliApp = class {
 			body.split("\n").forEach((rawLine) => {
 				const line = rawLine.trim();
 				if (!line || line.startsWith("@@") || line.startsWith("//")) return;
-				const fieldMatch = line.match(/^(\w+)\s+([A-Za-z]+)(\?)?(?:\s|$)/);
+				const fieldMatch = line.match(/^(\w+)\s+([A-Za-z][A-Za-z0-9_]*)(\[\])?(\?)?(?:\s|$)/);
 				if (!fieldMatch) return;
 				const fieldType = fieldMatch[2];
-				if (!scalarTypes.has(fieldType)) return;
+				if (!scalarTypes.has(fieldType) && !enumDefinitions.has(fieldType)) return;
+				const declarationType = this.prismaFieldTypeToTs(fieldType, Boolean(fieldMatch[3]), enumDefinitions);
+				if (!declarationType) return;
 				fields.push({
 					name: fieldMatch[1],
-					type: this.prismaTypeToTs(fieldType),
-					nullable: Boolean(fieldMatch[3])
+					type: declarationType,
+					nullable: Boolean(fieldMatch[4])
 				});
 			});
 			models.push({
@@ -1931,7 +2162,7 @@ var CliApp = class {
 	* @param declarations  A list of attribute declarations to sync.
 	* @returns An object containing the updated content and a flag indicating if it was updated.
 	*/
-	syncModelDeclarations(modelSource, declarations) {
+	syncModelDeclarations(modelSource, declarations, enums) {
 		const lines = modelSource.split("\n");
 		const classIndex = lines.findIndex((line) => /export\s+class\s+\w+\s+extends\s+Model<.+>\s*\{/.test(line));
 		if (classIndex < 0) return {
@@ -1953,16 +2184,38 @@ var CliApp = class {
 			content: modelSource,
 			updated: false
 		};
-		const withoutDeclares = lines.slice(classIndex + 1, classEndIndex).filter((line) => !/^\s*declare\s+\w+\??:\s*[^\n]+$/.test(line));
-		const rebuiltClass = [...declarations.map((declaration) => `    ${declaration}`), ...withoutDeclares];
+		const withinClass = lines.slice(classIndex + 1, classEndIndex);
+		const existingDeclarations = /* @__PURE__ */ new Map();
+		withinClass.forEach((line) => {
+			const declarationMatch = line.match(/^\s*declare\s+(\w+)\??:\s*([^;\n]+);?\s*$/);
+			if (!declarationMatch) return;
+			existingDeclarations.set(declarationMatch[1], {
+				name: declarationMatch[1],
+				raw: line.trim(),
+				type: declarationMatch[2].trim()
+			});
+		});
+		const withoutDeclares = withinClass.filter((line) => !/^\s*declare\s+\w+\??:\s*[^\n]+$/.test(line));
+		const chosenDeclarations = declarations.map((declaration) => {
+			const expectedType = `${declaration.type}${declaration.nullable ? " | null" : ""}`;
+			const existingDeclaration = existingDeclarations.get(declaration.name);
+			if (existingDeclaration && this.isCompatibleDeclarationType(existingDeclaration.type, expectedType, enums)) return existingDeclaration.raw;
+			return `declare ${declaration.name}: ${expectedType}`;
+		});
+		const rebuiltClass = [...chosenDeclarations.map((declaration) => `    ${declaration}`), ...withoutDeclares];
 		const content = [
 			...lines.slice(0, classIndex + 1),
 			...rebuiltClass,
 			...lines.slice(classEndIndex)
 		].join("\n");
+		const enumImports = [...new Set(chosenDeclarations.flatMap((declaration) => {
+			const type = declaration.replace(/^declare\s+\w+\??:\s*/, "").replace(/;$/, "").trim();
+			return this.collectEnumReferences(type, enums);
+		}))].sort((left, right) => left.localeCompare(right));
+		const contentWithImports = this.syncPrismaEnumImports(content, enumImports);
 		return {
-			content,
-			updated: content !== modelSource
+			content: contentWithImports,
+			updated: contentWithImports !== modelSource
 		};
 	}
 	/**
@@ -1982,6 +2235,7 @@ var CliApp = class {
 		if (!existsSync$1(schemaPath)) throw new Error(`Prisma schema file not found: ${schemaPath}`);
 		if (!existsSync$1(modelsDir)) throw new Error(`Models directory not found: ${modelsDir}`);
 		const schema = readFileSync$1(schemaPath, "utf-8");
+		const prismaEnums = this.parsePrismaEnums(schema);
 		const prismaModels = this.parsePrismaModels(schema);
 		const modelFiles = readdirSync$1(modelsDir).filter((file) => file.endsWith(".ts"));
 		const updated = [];
@@ -2001,8 +2255,7 @@ var CliApp = class {
 				skipped.push(filePath);
 				return;
 			}
-			const declarations = prismaModel.fields.map((field) => `declare ${field.name}: ${field.type}${field.nullable ? " | null" : ""}`);
-			const synced = this.syncModelDeclarations(source, declarations);
+			const synced = this.syncModelDeclarations(source, prismaModel.fields, prismaEnums);
 			if (!synced.updated) {
 				skipped.push(filePath);
 				return;
@@ -2424,7 +2677,7 @@ var MigrateCommand = class extends Command {
 	* @returns 
 	*/
 	async loadMigrationClassesFromFile(filePath) {
-		const imported = await import(`${pathToFileURL$1(resolve(filePath)).href}?arkorm_migrate=${Date.now()}`);
+		const imported = await RuntimeModuleLoader.load(filePath);
 		return Object.values(imported).filter((value) => {
 			if (typeof value !== "function") return false;
 			const candidate = value;
@@ -2509,7 +2762,7 @@ var MigrateRollbackCommand = class extends Command {
 		return (await Promise.all(files.map(async (file) => (await this.loadMigrationClassesFromFile(file)).map((cls) => [cls, file])))).flat();
 	}
 	async loadMigrationClassesFromFile(filePath) {
-		const imported = await import(`${pathToFileURL$1(resolve(filePath)).href}?arkorm_rollback=${Date.now()}`);
+		const imported = await RuntimeModuleLoader.load(filePath);
 		return Object.values(imported).filter((value) => {
 			if (typeof value !== "function") return false;
 			const candidate = value;
@@ -2719,7 +2972,7 @@ var SeedCommand = class extends Command {
 	* @returns An array of seeder classes.
 	*/
 	async loadSeederClassesFromFile(filePath) {
-		const imported = await import(`${pathToFileURL$1(resolve(filePath)).href}?arkorm_seed=${Date.now()}`);
+		const imported = await RuntimeModuleLoader.load(filePath);
 		return Object.values(imported).filter((value) => {
 			if (typeof value !== "function") return false;
 			const candidate = value;