@geekmidas/cli 0.0.8 → 0.0.9

package/dist/{build-HqXSd7ux.mjs → build-CE77jmn4.mjs}

@@ -1,7 +1,9 @@
-import { loadConfig } from "./config-DV1Lwdkx.mjs";
+import { loadConfig } from "./config-Nd751N3o.mjs";
 import { loadEndpoints } from "./loadEndpoints-BL8q2rTO.mjs";
+import { loadTsConfig } from "./tsconfig-BtO228Cz.mjs";
+import { resolveModuleSpecifier } from "./pathResolver-DaMnbf26.mjs";
 import { mkdir, writeFile } from "node:fs/promises";
-import { dirname, join, relative } from "path";
+import { join, relative } from "path";
 
 //#region src/build.ts
 const logger = console;
@@ -10,6 +12,8 @@ async function buildCommand(options) {
 	const config = await loadConfig();
 	logger.log(`Loading routes from: ${config.routes}`);
 	logger.log(`Using envParser: ${config.envParser}`);
+	const tsConfig = config.tsconfig ? loadTsConfig(config.tsconfig) : loadTsConfig();
+	if (tsConfig) logger.log(`Using TypeScript config from: ${tsConfig.configPath}`);
 	const [envParserPath, envParserName] = config.envParser.split("#");
 	const envParserImportPattern = !envParserName ? "envParser" : envParserName === "envParser" ? "{ envParser }" : `{ ${envParserName} as envParser }`;
 	const [loggerPath, loggerName] = config.logger.split("#");
@@ -39,7 +43,7 @@ async function buildCommand(options) {
 		await mkdir(outputDir, { recursive: true });
 		logger.log(`\nGenerating handlers for provider: ${provider}`);
 		if (provider === "server") {
-			const serverFile = await generateServerFile(outputDir, allEndpoints, envParserPath, envParserImportPattern, loggerPath, loggerImportPattern);
+			const serverFile = await generateServerFile(outputDir, allEndpoints, envParserPath, envParserImportPattern, loggerPath, loggerImportPattern, tsConfig);
 			routes.push({
 				path: "*",
 				method: "ALL",
@@ -47,7 +51,7 @@ async function buildCommand(options) {
 			});
 			logger.log(`Generated server app with ${allEndpoints.length} endpoints`);
 		} else for (const { file, exportName, routeInfo } of allEndpoints) {
-			const handlerFile = await generateHandlerFile(outputDir, file, exportName, provider, routeInfo, envParserPath, envParserImportPattern);
+			const handlerFile = await generateHandlerFile(outputDir, file, exportName, provider, routeInfo, envParserPath, envParserImportPattern, tsConfig);
 			routes.push({
 				...routeInfo,
 				handler: relative(process.cwd(), handlerFile).replace(/\.ts$/, ".handler")
@@ -61,18 +65,18 @@ async function buildCommand(options) {
 		logger.log(`Routes manifest: ${relative(process.cwd(), manifestPath)}`);
 	}
 }
-async function generateServerFile(outputDir, endpoints, envParserPath, envParserImportPattern, loggerPath, loggerImportPattern) {
+async function generateServerFile(outputDir, endpoints, envParserPath, envParserImportPattern, loggerPath, loggerImportPattern, tsConfig) {
 	const serverFileName = "app.ts";
 	const serverPath = join(outputDir, serverFileName);
 	const importsByFile = /* @__PURE__ */ new Map();
 	for (const { file, exportName } of endpoints) {
-		const relativePath = relative(dirname(serverPath), file);
-		const importPath = relativePath.replace(/\.ts$/, ".js");
+		const absoluteFilePath = join(process.cwd(), file);
+		const importPath = resolveModuleSpecifier(serverPath, absoluteFilePath, tsConfig);
 		if (!importsByFile.has(importPath)) importsByFile.set(importPath, []);
 		importsByFile.get(importPath).push(exportName);
 	}
-	const relativeEnvParserPath = relative(dirname(serverPath), envParserPath);
-	const relativeLoggerPath = relative(dirname(serverPath), loggerPath);
+	const relativeEnvParserPath = resolveModuleSpecifier(serverPath, envParserPath, tsConfig);
+	const relativeLoggerPath = resolveModuleSpecifier(serverPath, loggerPath, tsConfig);
 	const imports = Array.from(importsByFile.entries()).map(([importPath, exports]) => `import { ${exports.join(", ")} } from '${importPath}';`).join("\n");
 	const allExportNames = endpoints.map(({ exportName }) => exportName);
 	const content = `import { HonoEndpoint } from '@geekmidas/api/hono';
@@ -106,12 +110,12 @@ export default createApp;
 	await writeFile(serverPath, content);
 	return serverPath;
 }
-async function generateHandlerFile(outputDir, sourceFile, exportName, provider, _routeInfo, envParserPath, envParserImportPattern) {
+async function generateHandlerFile(outputDir, sourceFile, exportName, provider, _routeInfo, envParserPath, envParserImportPattern, tsConfig) {
 	const handlerFileName = `${exportName}.ts`;
 	const handlerPath = join(outputDir, handlerFileName);
-	const relativePath = relative(dirname(handlerPath), sourceFile);
-	const importPath = relativePath.replace(/\.ts$/, ".js");
-	const relativeEnvParserPath = relative(dirname(handlerPath), envParserPath);
+	const absoluteSourcePath = join(process.cwd(), sourceFile);
+	const importPath = resolveModuleSpecifier(handlerPath, absoluteSourcePath, tsConfig);
+	const relativeEnvParserPath = resolveModuleSpecifier(handlerPath, envParserPath, tsConfig);
 	let content;
 	switch (provider) {
 		case "aws-apigatewayv1":

package/dist/{build-BOIEItQ4.cjs → build-DGJAXiy_.cjs}

@@ -1,6 +1,8 @@
 const require_chunk = require('./chunk-CUT6urMc.cjs');
-const require_config = require('./config-D8AyiwBU.cjs');
+const require_config = require('./config-D-b45V57.cjs');
 const require_loadEndpoints = require('./loadEndpoints-CYFwuPZr.cjs');
+const require_tsconfig = require('./tsconfig-83amrDAp.cjs');
+const require_pathResolver = require('./pathResolver-B6y4yoWk.cjs');
 const node_fs_promises = require_chunk.__toESM(require("node:fs/promises"));
 const path = require_chunk.__toESM(require("path"));
 
@@ -11,6 +13,8 @@ async function buildCommand(options) {
 	const config = await require_config.loadConfig();
 	logger.log(`Loading routes from: ${config.routes}`);
 	logger.log(`Using envParser: ${config.envParser}`);
+	const tsConfig = config.tsconfig ? require_tsconfig.loadTsConfig(config.tsconfig) : require_tsconfig.loadTsConfig();
+	if (tsConfig) logger.log(`Using TypeScript config from: ${tsConfig.configPath}`);
 	const [envParserPath, envParserName] = config.envParser.split("#");
 	const envParserImportPattern = !envParserName ? "envParser" : envParserName === "envParser" ? "{ envParser }" : `{ ${envParserName} as envParser }`;
 	const [loggerPath, loggerName] = config.logger.split("#");
@@ -40,7 +44,7 @@ async function buildCommand(options) {
 		await (0, node_fs_promises.mkdir)(outputDir, { recursive: true });
 		logger.log(`\nGenerating handlers for provider: ${provider}`);
 		if (provider === "server") {
-			const serverFile = await generateServerFile(outputDir, allEndpoints, envParserPath, envParserImportPattern, loggerPath, loggerImportPattern);
+			const serverFile = await generateServerFile(outputDir, allEndpoints, envParserPath, envParserImportPattern, loggerPath, loggerImportPattern, tsConfig);
 			routes.push({
 				path: "*",
 				method: "ALL",
@@ -48,7 +52,7 @@ async function buildCommand(options) {
 			});
 			logger.log(`Generated server app with ${allEndpoints.length} endpoints`);
 		} else for (const { file, exportName, routeInfo } of allEndpoints) {
-			const handlerFile = await generateHandlerFile(outputDir, file, exportName, provider, routeInfo, envParserPath, envParserImportPattern);
+			const handlerFile = await generateHandlerFile(outputDir, file, exportName, provider, routeInfo, envParserPath, envParserImportPattern, tsConfig);
 			routes.push({
 				...routeInfo,
 				handler: (0, path.relative)(process.cwd(), handlerFile).replace(/\.ts$/, ".handler")
@@ -62,18 +66,18 @@ async function buildCommand(options) {
 		logger.log(`Routes manifest: ${(0, path.relative)(process.cwd(), manifestPath)}`);
 	}
 }
-async function generateServerFile(outputDir, endpoints, envParserPath, envParserImportPattern, loggerPath, loggerImportPattern) {
+async function generateServerFile(outputDir, endpoints, envParserPath, envParserImportPattern, loggerPath, loggerImportPattern, tsConfig) {
 	const serverFileName = "app.ts";
 	const serverPath = (0, path.join)(outputDir, serverFileName);
 	const importsByFile = /* @__PURE__ */ new Map();
 	for (const { file, exportName } of endpoints) {
-		const relativePath = (0, path.relative)((0, path.dirname)(serverPath), file);
-		const importPath = relativePath.replace(/\.ts$/, ".js");
+		const absoluteFilePath = (0, path.join)(process.cwd(), file);
+		const importPath = require_pathResolver.resolveModuleSpecifier(serverPath, absoluteFilePath, tsConfig);
 		if (!importsByFile.has(importPath)) importsByFile.set(importPath, []);
 		importsByFile.get(importPath).push(exportName);
 	}
-	const relativeEnvParserPath = (0, path.relative)((0, path.dirname)(serverPath), envParserPath);
-	const relativeLoggerPath = (0, path.relative)((0, path.dirname)(serverPath), loggerPath);
+	const relativeEnvParserPath = require_pathResolver.resolveModuleSpecifier(serverPath, envParserPath, tsConfig);
+	const relativeLoggerPath = require_pathResolver.resolveModuleSpecifier(serverPath, loggerPath, tsConfig);
 	const imports = Array.from(importsByFile.entries()).map(([importPath, exports$1]) => `import { ${exports$1.join(", ")} } from '${importPath}';`).join("\n");
 	const allExportNames = endpoints.map(({ exportName }) => exportName);
 	const content = `import { HonoEndpoint } from '@geekmidas/api/hono';
@@ -107,12 +111,12 @@ export default createApp;
 	await (0, node_fs_promises.writeFile)(serverPath, content);
 	return serverPath;
 }
-async function generateHandlerFile(outputDir, sourceFile, exportName, provider, _routeInfo, envParserPath, envParserImportPattern) {
+async function generateHandlerFile(outputDir, sourceFile, exportName, provider, _routeInfo, envParserPath, envParserImportPattern, tsConfig) {
 	const handlerFileName = `${exportName}.ts`;
 	const handlerPath = (0, path.join)(outputDir, handlerFileName);
-	const relativePath = (0, path.relative)((0, path.dirname)(handlerPath), sourceFile);
-	const importPath = relativePath.replace(/\.ts$/, ".js");
-	const relativeEnvParserPath = (0, path.relative)((0, path.dirname)(handlerPath), envParserPath);
+	const absoluteSourcePath = (0, path.join)(process.cwd(), sourceFile);
+	const importPath = require_pathResolver.resolveModuleSpecifier(handlerPath, absoluteSourcePath, tsConfig);
+	const relativeEnvParserPath = require_pathResolver.resolveModuleSpecifier(handlerPath, envParserPath, tsConfig);
 	let content;
 	switch (provider) {
 		case "aws-apigatewayv1":

package/dist/build.cjs

@@ -1,5 +1,7 @@
-require('./config-D8AyiwBU.cjs');
+require('./config-D-b45V57.cjs');
 require('./loadEndpoints-CYFwuPZr.cjs');
-const require_build = require('./build-BOIEItQ4.cjs');
+require('./tsconfig-83amrDAp.cjs');
+require('./pathResolver-B6y4yoWk.cjs');
+const require_build = require('./build-DGJAXiy_.cjs');
 
 exports.buildCommand = require_build.buildCommand;

package/dist/build.mjs

@@ -1,5 +1,7 @@
-import "./config-DV1Lwdkx.mjs";
+import "./config-Nd751N3o.mjs";
 import "./loadEndpoints-BL8q2rTO.mjs";
-import { buildCommand } from "./build-HqXSd7ux.mjs";
+import "./tsconfig-BtO228Cz.mjs";
+import "./pathResolver-DaMnbf26.mjs";
+import { buildCommand } from "./build-CE77jmn4.mjs";
 
 export { buildCommand };

package/dist/{cli-8JB9d4XW.mjs → cli-CTfdNl5c.mjs}

@@ -1,5 +1,5 @@
-import { buildCommand } from "./build-HqXSd7ux.mjs";
-import { openapiCommand } from "./openapi-CVu3aUU8.mjs";
+import { buildCommand } from "./build-CE77jmn4.mjs";
+import { openapiCommand } from "./openapi-UIMy3Lzi.mjs";
 import { Command } from "commander";
 
 //#region src/cli.ts

package/dist/{cli-8aXEWjpV.cjs → cli-aXPCpkGS.cjs}

@@ -1,6 +1,6 @@
 const require_chunk = require('./chunk-CUT6urMc.cjs');
-const require_build = require('./build-BOIEItQ4.cjs');
-const require_openapi = require('./openapi-DD-MfKrj.cjs');
+const require_build = require('./build-DGJAXiy_.cjs');
+const require_openapi = require('./openapi-C84tyelp.cjs');
 const commander = require_chunk.__toESM(require("commander"));
 
 //#region src/cli.ts

package/dist/cli.cjs

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
-require('./config-D8AyiwBU.cjs');
+require('./config-D-b45V57.cjs');
 require('./loadEndpoints-CYFwuPZr.cjs');
-require('./build-BOIEItQ4.cjs');
-require('./openapi-DD-MfKrj.cjs');
-require('./cli-8aXEWjpV.cjs');
+require('./tsconfig-83amrDAp.cjs');
+require('./pathResolver-B6y4yoWk.cjs');
+require('./build-DGJAXiy_.cjs');
+require('./openapi-C84tyelp.cjs');
+require('./cli-aXPCpkGS.cjs');

package/dist/cli.mjs

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
-import "./config-DV1Lwdkx.mjs";
+import "./config-Nd751N3o.mjs";
 import "./loadEndpoints-BL8q2rTO.mjs";
-import "./build-HqXSd7ux.mjs";
-import "./openapi-CVu3aUU8.mjs";
-import "./cli-8JB9d4XW.mjs";
+import "./tsconfig-BtO228Cz.mjs";
+import "./pathResolver-DaMnbf26.mjs";
+import "./build-CE77jmn4.mjs";
+import "./openapi-UIMy3Lzi.mjs";
+import "./cli-CTfdNl5c.mjs";

package/dist/config-D-b45V57.cjs

@@ -0,0 +1,41 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const path = require_chunk.__toESM(require("path"));
+const fs = require_chunk.__toESM(require("fs"));
+
+//#region src/config.ts
+async function loadConfig() {
+	const cwd = process.cwd();
+	const configExtensions = [
+		".ts",
+		".js",
+		".json"
+	];
+	let configPath = null;
+	for (const ext of configExtensions) {
+		const path$1 = (0, path.join)(cwd, `gkm.config${ext}`);
+		if ((0, fs.existsSync)(path$1)) {
+			configPath = path$1;
+			break;
+		}
+	}
+	if (!configPath) throw new Error("gkm.config.{ts,js,json} not found. Please create a configuration file.");
+	try {
+		const ext = (0, path.extname)(configPath);
+		if (ext === ".ts") {
+			const config$1 = await import(configPath);
+			return config$1.default || config$1;
+		}
+		const config = await import(configPath);
+		return config.default || config;
+	} catch (error) {
+		throw new Error(`Failed to load ${configPath}: ${error.message}`);
+	}
+}
+
+//#endregion
+Object.defineProperty(exports, 'loadConfig', {
+  enumerable: true,
+  get: function () {
+    return loadConfig;
+  }
+});

package/dist/config-Nd751N3o.mjs

@@ -0,0 +1,35 @@
+import { extname, join } from "path";
+import { existsSync } from "fs";
+
+//#region src/config.ts
+async function loadConfig() {
+	const cwd = process.cwd();
+	const configExtensions = [
+		".ts",
+		".js",
+		".json"
+	];
+	let configPath = null;
+	for (const ext of configExtensions) {
+		const path = join(cwd, `gkm.config${ext}`);
+		if (existsSync(path)) {
+			configPath = path;
+			break;
+		}
+	}
+	if (!configPath) throw new Error("gkm.config.{ts,js,json} not found. Please create a configuration file.");
+	try {
+		const ext = extname(configPath);
+		if (ext === ".ts") {
+			const config$1 = await import(configPath);
+			return config$1.default || config$1;
+		}
+		const config = await import(configPath);
+		return config.default || config;
+	} catch (error) {
+		throw new Error(`Failed to load ${configPath}: ${error.message}`);
+	}
+}
+
+//#endregion
+export { loadConfig };

package/dist/config.cjs

@@ -1,3 +1,3 @@
-const require_config = require('./config-D8AyiwBU.cjs');
+const require_config = require('./config-D-b45V57.cjs');
 
 exports.loadConfig = require_config.loadConfig;

package/dist/config.mjs

@@ -1,3 +1,3 @@
-import { loadConfig } from "./config-DV1Lwdkx.mjs";
+import { loadConfig } from "./config-Nd751N3o.mjs";
 
 export { loadConfig };

package/dist/helpers/pathResolver.cjs

@@ -0,0 +1,6 @@
+require('../tsconfig-83amrDAp.cjs');
+const require_pathResolver = require('../pathResolver-B6y4yoWk.cjs');
+
+exports.convertToJsExtension = require_pathResolver.convertToJsExtension;
+exports.resolveImportPath = require_pathResolver.resolveImportPath;
+exports.resolveModuleSpecifier = require_pathResolver.resolveModuleSpecifier;

package/dist/helpers/pathResolver.mjs

@@ -0,0 +1,4 @@
+import "../tsconfig-BtO228Cz.mjs";
+import { convertToJsExtension, resolveImportPath, resolveModuleSpecifier } from "../pathResolver-DaMnbf26.mjs";
+
+export { convertToJsExtension, resolveImportPath, resolveModuleSpecifier };

package/dist/index.cjs

@@ -1,6 +1,8 @@
 #!/usr/bin/env -S npx tsx
-require('./config-D8AyiwBU.cjs');
+require('./config-D-b45V57.cjs');
 require('./loadEndpoints-CYFwuPZr.cjs');
-require('./build-BOIEItQ4.cjs');
-require('./openapi-DD-MfKrj.cjs');
-require('./cli-8aXEWjpV.cjs');
+require('./tsconfig-83amrDAp.cjs');
+require('./pathResolver-B6y4yoWk.cjs');
+require('./build-DGJAXiy_.cjs');
+require('./openapi-C84tyelp.cjs');
+require('./cli-aXPCpkGS.cjs');

package/dist/index.mjs

@@ -1,6 +1,8 @@
 #!/usr/bin/env -S npx tsx
-import "./config-DV1Lwdkx.mjs";
+import "./config-Nd751N3o.mjs";
 import "./loadEndpoints-BL8q2rTO.mjs";
-import "./build-HqXSd7ux.mjs";
-import "./openapi-CVu3aUU8.mjs";
-import "./cli-8JB9d4XW.mjs";
+import "./tsconfig-BtO228Cz.mjs";
+import "./pathResolver-DaMnbf26.mjs";
+import "./build-CE77jmn4.mjs";
+import "./openapi-UIMy3Lzi.mjs";
+import "./cli-CTfdNl5c.mjs";

package/dist/{openapi-DD-MfKrj.cjs → openapi-C84tyelp.cjs}

@@ -1,5 +1,5 @@
 const require_chunk = require('./chunk-CUT6urMc.cjs');
-const require_config = require('./config-D8AyiwBU.cjs');
+const require_config = require('./config-D-b45V57.cjs');
 const require_loadEndpoints = require('./loadEndpoints-CYFwuPZr.cjs');
 const node_fs_promises = require_chunk.__toESM(require("node:fs/promises"));
 const __geekmidas_api_server = require_chunk.__toESM(require("@geekmidas/api/server"));

package/dist/{openapi-CVu3aUU8.mjs → openapi-UIMy3Lzi.mjs}

@@ -1,4 +1,4 @@
-import { loadConfig } from "./config-DV1Lwdkx.mjs";
+import { loadConfig } from "./config-Nd751N3o.mjs";
 import { loadEndpoints } from "./loadEndpoints-BL8q2rTO.mjs";
 import { mkdir, writeFile } from "node:fs/promises";
 import { Endpoint } from "@geekmidas/api/server";

package/dist/openapi.cjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env -S npx tsx
-require('./config-D8AyiwBU.cjs');
+require('./config-D-b45V57.cjs');
 require('./loadEndpoints-CYFwuPZr.cjs');
-const require_openapi = require('./openapi-DD-MfKrj.cjs');
+const require_openapi = require('./openapi-C84tyelp.cjs');
 
 exports.openapiCommand = require_openapi.openapiCommand;

package/dist/openapi.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env -S npx tsx
-import "./config-DV1Lwdkx.mjs";
+import "./config-Nd751N3o.mjs";
 import "./loadEndpoints-BL8q2rTO.mjs";
-import { openapiCommand } from "./openapi-CVu3aUU8.mjs";
+import { openapiCommand } from "./openapi-UIMy3Lzi.mjs";
 
 export { openapiCommand };

package/dist/pathResolver-B6y4yoWk.cjs

@@ -0,0 +1,47 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const require_tsconfig = require('./tsconfig-83amrDAp.cjs');
+const path = require_chunk.__toESM(require("path"));
+
+//#region src/helpers/pathResolver.ts
+/**
+* Resolve import paths considering TypeScript path mappings
+*/
+function resolveImportPath(fromFile, toFile, tsConfig) {
+	const resolvedToFile = tsConfig ? require_tsconfig.resolvePathMapping(toFile, tsConfig) : toFile;
+	const relativePath = (0, path.relative)((0, path.dirname)(fromFile), resolvedToFile);
+	if (!relativePath.startsWith(".")) return `./${relativePath}`;
+	return relativePath;
+}
+/**
+* Convert TypeScript file extensions to JavaScript
+*/
+function convertToJsExtension(filePath) {
+	return filePath.replace(/\.ts$/, ".js");
+}
+/**
+* Resolve module specifier for imports
+*/
+function resolveModuleSpecifier(fromFile, toFile, tsConfig) {
+	const importPath = resolveImportPath(fromFile, toFile, tsConfig);
+	return convertToJsExtension(importPath);
+}
+
+//#endregion
+Object.defineProperty(exports, 'convertToJsExtension', {
+  enumerable: true,
+  get: function () {
+    return convertToJsExtension;
+  }
+});
+Object.defineProperty(exports, 'resolveImportPath', {
+  enumerable: true,
+  get: function () {
+    return resolveImportPath;
+  }
+});
+Object.defineProperty(exports, 'resolveModuleSpecifier', {
+  enumerable: true,
+  get: function () {
+    return resolveModuleSpecifier;
+  }
+});

package/dist/pathResolver-DaMnbf26.mjs

@@ -0,0 +1,29 @@
+import { resolvePathMapping } from "./tsconfig-BtO228Cz.mjs";
+import { dirname, relative } from "path";
+
+//#region src/helpers/pathResolver.ts
+/**
+* Resolve import paths considering TypeScript path mappings
+*/
+function resolveImportPath(fromFile, toFile, tsConfig) {
+	const resolvedToFile = tsConfig ? resolvePathMapping(toFile, tsConfig) : toFile;
+	const relativePath = relative(dirname(fromFile), resolvedToFile);
+	if (!relativePath.startsWith(".")) return `./${relativePath}`;
+	return relativePath;
+}
+/**
+* Convert TypeScript file extensions to JavaScript
+*/
+function convertToJsExtension(filePath) {
+	return filePath.replace(/\.ts$/, ".js");
+}
+/**
+* Resolve module specifier for imports
+*/
+function resolveModuleSpecifier(fromFile, toFile, tsConfig) {
+	const importPath = resolveImportPath(fromFile, toFile, tsConfig);
+	return convertToJsExtension(importPath);
+}
+
+//#endregion
+export { convertToJsExtension, resolveImportPath, resolveModuleSpecifier };

package/dist/tsconfig-83amrDAp.cjs

@@ -0,0 +1,94 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const path = require_chunk.__toESM(require("path"));
+const fs = require_chunk.__toESM(require("fs"));
+const typescript = require_chunk.__toESM(require("typescript"));
+
+//#region src/tsconfig.ts
+/**
+* Find and parse the nearest tsconfig.json file
+*/
+function loadTsConfig(searchPath = process.cwd()) {
+	const configPath = typescript.default.findConfigFile(searchPath, fs.existsSync);
+	if (!configPath) return null;
+	const configFile = typescript.default.readConfigFile(configPath, typescript.default.sys.readFile);
+	if (configFile.error) throw new Error(`Error reading tsconfig.json: ${typescript.default.flattenDiagnosticMessageText(configFile.error.messageText, "\n")}`);
+	const parsedConfig = typescript.default.parseJsonConfigFileContent(configFile.config, typescript.default.sys, (0, path.dirname)(configPath));
+	if (parsedConfig.errors.length > 0) {
+		const errors = parsedConfig.errors.map((error) => typescript.default.flattenDiagnosticMessageText(error.messageText, "\n")).join("\n");
+		throw new Error(`Error parsing tsconfig.json: ${errors}`);
+	}
+	return {
+		configPath,
+		config: parsedConfig,
+		compilerOptions: parsedConfig.options
+	};
+}
+/**
+* Resolve a module path using TypeScript's module resolution
+*/
+function resolveModulePath(moduleName, containingFile, tsConfig) {
+	const compilerOptions = tsConfig?.compilerOptions || {};
+	const result = typescript.default.resolveModuleName(moduleName, containingFile, compilerOptions, typescript.default.sys);
+	if (result.resolvedModule) return result.resolvedModule.resolvedFileName;
+	return null;
+}
+/**
+* Get the output path for a TypeScript file based on tsconfig
+*/
+function getOutputPath(filePath, tsConfig) {
+	if (!tsConfig) return filePath.replace(/\.ts$/, ".js");
+	const { compilerOptions, configPath } = tsConfig;
+	const configDir = (0, path.dirname)(configPath);
+	if (compilerOptions.outDir) {
+		const rootDir = compilerOptions.rootDir || configDir;
+		const relativePath = filePath.startsWith(rootDir) ? filePath.slice(rootDir.length) : filePath;
+		const outputPath = (0, path.join)(compilerOptions.outDir, relativePath);
+		return outputPath.replace(/\.ts$/, ".js");
+	}
+	return filePath.replace(/\.ts$/, ".js");
+}
+/**
+* Apply path mappings from tsconfig paths
+*/
+function resolvePathMapping(importPath, tsConfig) {
+	if (!tsConfig || !tsConfig.compilerOptions.paths) return importPath;
+	const { paths, baseUrl } = tsConfig.compilerOptions;
+	const configDir = (0, path.dirname)(tsConfig.configPath);
+	const resolvedBaseUrl = baseUrl ? (0, path.resolve)(configDir, baseUrl) : configDir;
+	for (const [pattern, replacements] of Object.entries(paths)) {
+		const regex = new RegExp("^" + pattern.replace("*", "(.*)") + "$");
+		const match = importPath.match(regex);
+		if (match && replacements.length > 0) {
+			const replacement = replacements[0];
+			const resolvedPath = replacement.replace("*", match[1] || "");
+			return (0, path.resolve)(resolvedBaseUrl, resolvedPath);
+		}
+	}
+	return importPath;
+}
+
+//#endregion
+Object.defineProperty(exports, 'getOutputPath', {
+  enumerable: true,
+  get: function () {
+    return getOutputPath;
+  }
+});
+Object.defineProperty(exports, 'loadTsConfig', {
+  enumerable: true,
+  get: function () {
+    return loadTsConfig;
+  }
+});
+Object.defineProperty(exports, 'resolveModulePath', {
+  enumerable: true,
+  get: function () {
+    return resolveModulePath;
+  }
+});
+Object.defineProperty(exports, 'resolvePathMapping', {
+  enumerable: true,
+  get: function () {
+    return resolvePathMapping;
+  }
+});

package/dist/tsconfig-BtO228Cz.mjs

@@ -0,0 +1,70 @@
+import { dirname, join, resolve } from "path";
+import { existsSync } from "fs";
+import ts from "typescript";
+
+//#region src/tsconfig.ts
+/**
+* Find and parse the nearest tsconfig.json file
+*/
+function loadTsConfig(searchPath = process.cwd()) {
+	const configPath = ts.findConfigFile(searchPath, existsSync);
+	if (!configPath) return null;
+	const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+	if (configFile.error) throw new Error(`Error reading tsconfig.json: ${ts.flattenDiagnosticMessageText(configFile.error.messageText, "\n")}`);
+	const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, dirname(configPath));
+	if (parsedConfig.errors.length > 0) {
+		const errors = parsedConfig.errors.map((error) => ts.flattenDiagnosticMessageText(error.messageText, "\n")).join("\n");
+		throw new Error(`Error parsing tsconfig.json: ${errors}`);
+	}
+	return {
+		configPath,
+		config: parsedConfig,
+		compilerOptions: parsedConfig.options
+	};
+}
+/**
+* Resolve a module path using TypeScript's module resolution
+*/
+function resolveModulePath(moduleName, containingFile, tsConfig) {
+	const compilerOptions = tsConfig?.compilerOptions || {};
+	const result = ts.resolveModuleName(moduleName, containingFile, compilerOptions, ts.sys);
+	if (result.resolvedModule) return result.resolvedModule.resolvedFileName;
+	return null;
+}
+/**
+* Get the output path for a TypeScript file based on tsconfig
+*/
+function getOutputPath(filePath, tsConfig) {
+	if (!tsConfig) return filePath.replace(/\.ts$/, ".js");
+	const { compilerOptions, configPath } = tsConfig;
+	const configDir = dirname(configPath);
+	if (compilerOptions.outDir) {
+		const rootDir = compilerOptions.rootDir || configDir;
+		const relativePath = filePath.startsWith(rootDir) ? filePath.slice(rootDir.length) : filePath;
+		const outputPath = join(compilerOptions.outDir, relativePath);
+		return outputPath.replace(/\.ts$/, ".js");
+	}
+	return filePath.replace(/\.ts$/, ".js");
+}
+/**
+* Apply path mappings from tsconfig paths
+*/
+function resolvePathMapping(importPath, tsConfig) {
+	if (!tsConfig || !tsConfig.compilerOptions.paths) return importPath;
+	const { paths, baseUrl } = tsConfig.compilerOptions;
+	const configDir = dirname(tsConfig.configPath);
+	const resolvedBaseUrl = baseUrl ? resolve(configDir, baseUrl) : configDir;
+	for (const [pattern, replacements] of Object.entries(paths)) {
+		const regex = new RegExp("^" + pattern.replace("*", "(.*)") + "$");
+		const match = importPath.match(regex);
+		if (match && replacements.length > 0) {
+			const replacement = replacements[0];
+			const resolvedPath = replacement.replace("*", match[1] || "");
+			return resolve(resolvedBaseUrl, resolvedPath);
+		}
+	}
+	return importPath;
+}
+
+//#endregion
+export { getOutputPath, loadTsConfig, resolveModulePath, resolvePathMapping };

package/dist/tsconfig.cjs

@@ -0,0 +1,6 @@
+const require_tsconfig = require('./tsconfig-83amrDAp.cjs');
+
+exports.getOutputPath = require_tsconfig.getOutputPath;
+exports.loadTsConfig = require_tsconfig.loadTsConfig;
+exports.resolveModulePath = require_tsconfig.resolveModulePath;
+exports.resolvePathMapping = require_tsconfig.resolvePathMapping;

package/dist/tsconfig.mjs

@@ -0,0 +1,3 @@
+import { getOutputPath, loadTsConfig, resolveModulePath, resolvePathMapping } from "./tsconfig-BtO228Cz.mjs";
+
+export { getOutputPath, loadTsConfig, resolveModulePath, resolvePathMapping };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/cli",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "private": false,
   "type": "module",
   "bin": {
@@ -19,11 +19,12 @@
   },
   "dependencies": {
     "commander": "~14.0.0",
+    "fast-glob": "~3.3.3",
     "lodash.get": "~4.4.2",
     "lodash.set": "~4.3.2",
+    "typescript": "~5.8.3",
     "zod": "~3.25.67",
-    "fast-glob": "~3.3.3",
-    "@geekmidas/api": "0.0.18"
+    "@geekmidas/api": "0.0.22"
   },
   "devDependencies": {
     "@types/lodash.get": "~4.4.9",

package/src/build.ts

@@ -2,6 +2,8 @@ import { mkdir, writeFile } from 'node:fs/promises';
 import { dirname, join, relative } from 'path';
 import { loadConfig } from './config.js';
 import { loadEndpoints } from './loadEndpoints.js';
+import { loadTsConfig, getOutputPath } from './tsconfig.js';
+import { resolveModuleSpecifier } from './helpers/pathResolver.js';
 import type {
   BuildOptions,
   Provider,
@@ -17,6 +19,14 @@ export async function buildCommand(options: BuildOptions): Promise<void> {
   logger.log(`Loading routes from: ${config.routes}`);
   logger.log(`Using envParser: ${config.envParser}`);
 
+  // Load tsconfig if available
+  const tsConfig = config.tsconfig
+    ? loadTsConfig(config.tsconfig)
+    : loadTsConfig();
+  if (tsConfig) {
+    logger.log(`Using TypeScript config from: ${tsConfig.configPath}`);
+  }
+
   // Parse envParser configuration
   const [envParserPath, envParserName] = config.envParser.split('#');
   const envParserImportPattern = !envParserName
@@ -80,6 +90,7 @@ export async function buildCommand(options: BuildOptions): Promise<void> {
         envParserImportPattern,
         loggerPath,
         loggerImportPattern,
+        tsConfig,
       );
 
       routes.push({
@@ -100,6 +111,7 @@ export async function buildCommand(options: BuildOptions): Promise<void> {
           routeInfo,
           envParserPath,
           envParserImportPattern,
+          tsConfig,
         );
 
         routes.push({
@@ -110,7 +122,9 @@ export async function buildCommand(options: BuildOptions): Promise<void> {
           ),
         });
 
-        logger.log(`Generated handler for ${routeInfo.method} ${routeInfo.path}`);
+        logger.log(
+          `Generated handler for ${routeInfo.method} ${routeInfo.path}`,
+        );
       }
     }
 
@@ -138,6 +152,7 @@ async function generateServerFile(
   envParserImportPattern: string,
   loggerPath: string,
   loggerImportPattern: string,
+  tsConfig: ReturnType<typeof loadTsConfig>,
 ): Promise<string> {
   const serverFileName = 'app.ts';
   const serverPath = join(outputDir, serverFileName);
@@ -146,8 +161,13 @@ async function generateServerFile(
   const importsByFile = new Map<string, string[]>();
 
   for (const { file, exportName } of endpoints) {
-    const relativePath = relative(dirname(serverPath), file);
-    const importPath = relativePath.replace(/\.ts$/, '.js');
+    const absoluteFilePath = join(process.cwd(), file);
+    // Use path resolver to handle tsconfig paths
+    const importPath = resolveModuleSpecifier(
+      serverPath,
+      absoluteFilePath,
+      tsConfig,
+    );
 
     if (!importsByFile.has(importPath)) {
       importsByFile.set(importPath, []);
@@ -155,8 +175,16 @@ async function generateServerFile(
     importsByFile.get(importPath)!.push(exportName);
   }
 
-  const relativeEnvParserPath = relative(dirname(serverPath), envParserPath);
-  const relativeLoggerPath = relative(dirname(serverPath), loggerPath);
+  const relativeEnvParserPath = resolveModuleSpecifier(
+    serverPath,
+    envParserPath,
+    tsConfig,
+  );
+  const relativeLoggerPath = resolveModuleSpecifier(
+    serverPath,
+    loggerPath,
+    tsConfig,
+  );
 
   // Generate import statements
   const imports = Array.from(importsByFile.entries())
@@ -209,14 +237,24 @@ async function generateHandlerFile(
   _routeInfo: RouteInfo,
   envParserPath: string,
   envParserImportPattern: string,
+  tsConfig: ReturnType<typeof loadTsConfig>,
 ): Promise<string> {
   const handlerFileName = `${exportName}.ts`;
   const handlerPath = join(outputDir, handlerFileName);
 
-  const relativePath = relative(dirname(handlerPath), sourceFile);
-  const importPath = relativePath.replace(/\.ts$/, '.js');
+  const absoluteSourcePath = join(process.cwd(), sourceFile);
+  // Use path resolver to handle tsconfig paths
+  const importPath = resolveModuleSpecifier(
+    handlerPath,
+    absoluteSourcePath,
+    tsConfig,
+  );
 
-  const relativeEnvParserPath = relative(dirname(handlerPath), envParserPath);
+  const relativeEnvParserPath = resolveModuleSpecifier(
+    handlerPath,
+    envParserPath,
+    tsConfig,
+  );
 
   let content: string;
 

package/src/cli.ts

@@ -27,7 +27,9 @@ program
       if (globalOptions.cwd) {
         process.chdir(globalOptions.cwd);
       }
-      const providerList = [...new Set(options.providers.split(',').map(p => p.trim()))] as Provider[];
+      const providerList = [
+        ...new Set(options.providers.split(',').map((p) => p.trim())),
+      ] as Provider[];
       await buildCommand({ providers: providerList });
     } catch (error) {
       console.error('Build failed:', (error as Error).message);

package/src/config.ts

@@ -1,22 +1,44 @@
 import { existsSync } from 'fs';
-import { join } from 'path';
+import { join, extname } from 'path';
 import type { GkmConfig } from './types.js';
 
 export async function loadConfig(): Promise<GkmConfig> {
-  const configPath = join(process.cwd(), 'gkm.config.json');
+  const cwd = process.cwd();
 
-  if (!existsSync(configPath)) {
+  // Try to find config file with different extensions
+  const configExtensions = ['.ts', '.js', '.json'];
+  let configPath: string | null = null;
+
+  for (const ext of configExtensions) {
+    const path = join(cwd, `gkm.config${ext}`);
+    if (existsSync(path)) {
+      configPath = path;
+      break;
+    }
+  }
+
+  if (!configPath) {
     throw new Error(
-      'gkm.config.json not found. Please create a configuration file.',
+      'gkm.config.{ts,js,json} not found. Please create a configuration file.',
     );
   }
 
   try {
+    const ext = extname(configPath);
+
+    // For TypeScript files, ensure tsx can handle them
+    if (ext === '.ts') {
+      // tsx handles TypeScript files automatically
+      const config = await import(configPath);
+      return config.default || config;
+    }
+
+    // For JS and JSON files
     const config = await import(configPath);
     return config.default || config;
   } catch (error) {
     throw new Error(
-      `Failed to load gkm.config.ts: ${(error as Error).message}`,
+      `Failed to load ${configPath}: ${(error as Error).message}`,
     );
   }
 }

package/src/helpers/pathResolver.ts

@@ -0,0 +1,46 @@
+import { relative, dirname } from 'path';
+import type { TsConfigResult } from '../tsconfig.js';
+import { resolvePathMapping } from '../tsconfig.js';
+
+/**
+ * Resolve import paths considering TypeScript path mappings
+ */
+export function resolveImportPath(
+  fromFile: string,
+  toFile: string,
+  tsConfig?: TsConfigResult | null,
+): string {
+  // Apply path mappings if tsconfig is available
+  const resolvedToFile = tsConfig
+    ? resolvePathMapping(toFile, tsConfig)
+    : toFile;
+
+  // Calculate relative path
+  const relativePath = relative(dirname(fromFile), resolvedToFile);
+
+  // Ensure proper relative path format
+  if (!relativePath.startsWith('.')) {
+    return `./${relativePath}`;
+  }
+
+  return relativePath;
+}
+
+/**
+ * Convert TypeScript file extensions to JavaScript
+ */
+export function convertToJsExtension(filePath: string): string {
+  return filePath.replace(/\.ts$/, '.js');
+}
+
+/**
+ * Resolve module specifier for imports
+ */
+export function resolveModuleSpecifier(
+  fromFile: string,
+  toFile: string,
+  tsConfig?: TsConfigResult | null,
+): string {
+  const importPath = resolveImportPath(fromFile, toFile, tsConfig);
+  return convertToJsExtension(importPath);
+}

package/src/tsconfig.ts

@@ -0,0 +1,132 @@
+import ts from 'typescript';
+import { existsSync } from 'fs';
+import { join, dirname, resolve } from 'path';
+
+export interface TsConfigResult {
+  configPath: string;
+  config: ts.ParsedCommandLine;
+  compilerOptions: ts.CompilerOptions;
+}
+
+/**
+ * Find and parse the nearest tsconfig.json file
+ */
+export function loadTsConfig(
+  searchPath: string = process.cwd(),
+): TsConfigResult | null {
+  const configPath = ts.findConfigFile(searchPath, existsSync);
+
+  if (!configPath) {
+    return null;
+  }
+
+  const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+
+  if (configFile.error) {
+    throw new Error(
+      `Error reading tsconfig.json: ${ts.flattenDiagnosticMessageText(configFile.error.messageText, '\n')}`,
+    );
+  }
+
+  const parsedConfig = ts.parseJsonConfigFileContent(
+    configFile.config,
+    ts.sys,
+    dirname(configPath),
+  );
+
+  if (parsedConfig.errors.length > 0) {
+    const errors = parsedConfig.errors
+      .map((error) => ts.flattenDiagnosticMessageText(error.messageText, '\n'))
+      .join('\n');
+    throw new Error(`Error parsing tsconfig.json: ${errors}`);
+  }
+
+  return {
+    configPath,
+    config: parsedConfig,
+    compilerOptions: parsedConfig.options,
+  };
+}
+
+/**
+ * Resolve a module path using TypeScript's module resolution
+ */
+export function resolveModulePath(
+  moduleName: string,
+  containingFile: string,
+  tsConfig?: TsConfigResult,
+): string | null {
+  const compilerOptions = tsConfig?.compilerOptions || {};
+
+  const result = ts.resolveModuleName(
+    moduleName,
+    containingFile,
+    compilerOptions,
+    ts.sys,
+  );
+
+  if (result.resolvedModule) {
+    return result.resolvedModule.resolvedFileName;
+  }
+
+  return null;
+}
+
+/**
+ * Get the output path for a TypeScript file based on tsconfig
+ */
+export function getOutputPath(
+  filePath: string,
+  tsConfig?: TsConfigResult,
+): string {
+  if (!tsConfig) {
+    // Default: replace .ts with .js
+    return filePath.replace(/\.ts$/, '.js');
+  }
+
+  const { compilerOptions, configPath } = tsConfig;
+  const configDir = dirname(configPath);
+
+  // Handle outDir option
+  if (compilerOptions.outDir) {
+    const rootDir = compilerOptions.rootDir || configDir;
+    const relativePath = filePath.startsWith(rootDir)
+      ? filePath.slice(rootDir.length)
+      : filePath;
+
+    const outputPath = join(compilerOptions.outDir, relativePath);
+    return outputPath.replace(/\.ts$/, '.js');
+  }
+
+  // Default: in-place compilation
+  return filePath.replace(/\.ts$/, '.js');
+}
+
+/**
+ * Apply path mappings from tsconfig paths
+ */
+export function resolvePathMapping(
+  importPath: string,
+  tsConfig?: TsConfigResult,
+): string {
+  if (!tsConfig || !tsConfig.compilerOptions.paths) {
+    return importPath;
+  }
+
+  const { paths, baseUrl } = tsConfig.compilerOptions;
+  const configDir = dirname(tsConfig.configPath);
+  const resolvedBaseUrl = baseUrl ? resolve(configDir, baseUrl) : configDir;
+
+  for (const [pattern, replacements] of Object.entries(paths)) {
+    const regex = new RegExp('^' + pattern.replace('*', '(.*)') + '$');
+    const match = importPath.match(regex);
+
+    if (match && replacements.length > 0) {
+      const replacement = replacements[0];
+      const resolvedPath = replacement.replace('*', match[1] || '');
+      return resolve(resolvedBaseUrl, resolvedPath);
+    }
+  }
+
+  return importPath;
+}

package/src/types.ts

@@ -6,6 +6,7 @@ export interface GkmConfig {
   routes: Routes;
   envParser: string;
   logger: string;
+  tsconfig?: string; // Optional path to tsconfig.json
 }
 
 export interface BuildOptions {

package/dist/config-D8AyiwBU.cjs

@@ -1,23 +0,0 @@
-const require_chunk = require('./chunk-CUT6urMc.cjs');
-const path = require_chunk.__toESM(require("path"));
-const fs = require_chunk.__toESM(require("fs"));
-
-//#region src/config.ts
-async function loadConfig() {
-	const configPath = (0, path.join)(process.cwd(), "gkm.config.json");
-	if (!(0, fs.existsSync)(configPath)) throw new Error("gkm.config.json not found. Please create a configuration file.");
-	try {
-		const config = await import(configPath);
-		return config.default || config;
-	} catch (error) {
-		throw new Error(`Failed to load gkm.config.ts: ${error.message}`);
-	}
-}
-
-//#endregion
-Object.defineProperty(exports, 'loadConfig', {
-  enumerable: true,
-  get: function () {
-    return loadConfig;
-  }
-});

package/dist/config-DV1Lwdkx.mjs

@@ -1,17 +0,0 @@
-import { join } from "path";
-import { existsSync } from "fs";
-
-//#region src/config.ts
-async function loadConfig() {
-	const configPath = join(process.cwd(), "gkm.config.json");
-	if (!existsSync(configPath)) throw new Error("gkm.config.json not found. Please create a configuration file.");
-	try {
-		const config = await import(configPath);
-		return config.default || config;
-	} catch (error) {
-		throw new Error(`Failed to load gkm.config.ts: ${error.message}`);
-	}
-}
-
-//#endregion
-export { loadConfig };