@geekmidas/cli 0.0.25 → 0.1.0

package/src/index.ts

@@ -2,10 +2,10 @@
 
 import { Command } from 'commander';
 import pkg from '../package.json' assert { type: 'json' };
-import { buildCommand } from './build.ts';
+import { buildCommand } from './build/index.ts';
 import { generateReactQueryCommand } from './openapi-react-query.ts';
 import { openapiCommand } from './openapi.ts';
-import type { Provider } from './types.ts';
+import type { LegacyProvider, MainProvider } from './types.ts';
 
 const program = new Command();
 
@@ -17,34 +17,69 @@ program
 
 program
   .command('build')
-  .description('Build API handlers from endpoints')
+  .description('Build handlers from endpoints, functions, and crons')
+  .option(
+    '--provider <provider>',
+    'Target provider for generated handlers (aws, server)',
+  )
   .option(
     '--providers <providers>',
-    'Target providers for generated handlers (comma-separated)',
-    'aws-apigatewayv1',
+    '[DEPRECATED] Use --provider instead. Target providers for generated handlers (comma-separated)',
   )
   .option(
     '--enable-openapi',
     'Enable OpenAPI documentation generation for server builds',
   )
-  .action(async (options: { providers: string; enableOpenapi?: boolean }) => {
-    try {
-      const globalOptions = program.opts();
-      if (globalOptions.cwd) {
-        process.chdir(globalOptions.cwd);
+  .action(
+    async (options: {
+      provider?: string;
+      providers?: string;
+      enableOpenapi?: boolean;
+    }) => {
+      try {
+        const globalOptions = program.opts();
+        if (globalOptions.cwd) {
+          process.chdir(globalOptions.cwd);
+        }
+
+        // Handle new single provider option
+        if (options.provider) {
+          if (!['aws', 'server'].includes(options.provider)) {
+            console.error(
+              `Invalid provider: ${options.provider}. Must be 'aws' or 'server'.`,
+            );
+            process.exit(1);
+          }
+          await buildCommand({
+            provider: options.provider as MainProvider,
+            enableOpenApi: options.enableOpenapi || false,
+          });
+        }
+        // Handle legacy providers option
+        else if (options.providers) {
+          console.warn(
+            '⚠️  --providers flag is deprecated. Use --provider instead.',
+          );
+          const providerList = [
+            ...new Set(options.providers.split(',').map((p) => p.trim())),
+          ] as LegacyProvider[];
+          await buildCommand({
+            providers: providerList,
+            enableOpenApi: options.enableOpenapi || false,
+          });
+        }
+        // Default to config-driven build
+        else {
+          await buildCommand({
+            enableOpenApi: options.enableOpenapi || false,
+          });
+        }
+      } catch (error) {
+        console.error('Build failed:', (error as Error).message);
+        process.exit(1);
       }
-      const providerList = [
-        ...new Set(options.providers.split(',').map((p) => p.trim())),
-      ] as Provider[];
-      await buildCommand({
-        providers: providerList,
-        enableOpenApi: options.enableOpenapi || false,
-      });
-    } catch (error) {
-      console.error('Build failed:', (error as Error).message);
-      process.exit(1);
-    }
-  });
+    },
+  );
 
 program
   .command('cron')

package/src/openapi.ts

@@ -4,7 +4,7 @@ import { mkdir, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { Endpoint } from '@geekmidas/api/server';
 import { loadConfig } from './config.js';
-import { loadEndpoints } from './loadEndpoints.js';
+import { EndpointGenerator } from './generators/EndpointGenerator.js';
 
 interface OpenAPIOptions {
   output?: string;
@@ -18,9 +18,10 @@ export async function openapiCommand(
   try {
     // Load config using existing function
     const config = await loadConfig();
+    const generator = new EndpointGenerator();
 
     // Load all endpoints using the refactored function
-    const loadedEndpoints = await loadEndpoints(config.routes);
+    const loadedEndpoints = await generator.load(config.routes);
 
     if (loadedEndpoints.length === 0) {
       logger.log('No valid endpoints found');
@@ -28,7 +29,7 @@ export async function openapiCommand(
     }
 
     // Extract just the endpoint instances for OpenAPI generation
-    const endpoints = loadedEndpoints.map(({ endpoint }) => endpoint);
+    const endpoints = loadedEndpoints.map(({ construct }) => construct);
 
     // Generate OpenAPI spec using built-in method
     const spec = await Endpoint.buildOpenApiSchema(endpoints, {

package/src/types.ts

@@ -1,15 +1,57 @@
-export type Provider = 'server' | 'aws-apigatewayv1' | 'aws-apigatewayv2';
+export type MainProvider = 'aws' | 'server';
+export type LegacyProvider =
+  | 'server'
+  | 'aws-apigatewayv1'
+  | 'aws-apigatewayv2'
+  | 'aws-lambda';
 
 export type Routes = string | string[];
 
+export interface ProviderConfig {
+  enabled?: boolean;
+  outputDir?: string;
+}
+
+export interface AWSApiGatewayConfig extends ProviderConfig {
+  // Additional AWS API Gateway specific options
+}
+
+export interface AWSLambdaConfig extends ProviderConfig {
+  // Additional AWS Lambda specific options
+}
+
+export interface ServerConfig extends ProviderConfig {
+  enableOpenApi?: boolean;
+  port?: number;
+}
+
+export interface ProvidersConfig {
+  aws?: {
+    apiGateway?: {
+      v1?: boolean | AWSApiGatewayConfig;
+      v2?: boolean | AWSApiGatewayConfig;
+    };
+    lambda?: {
+      functions?: boolean | AWSLambdaConfig;
+      crons?: boolean | AWSLambdaConfig;
+    };
+  };
+  server?: boolean | ServerConfig;
+}
+
 export interface GkmConfig {
   routes: Routes;
+  functions?: Routes;
+  crons?: Routes;
   envParser: string;
   logger: string;
+  providers?: ProvidersConfig;
 }
 
 export interface BuildOptions {
-  providers: Provider[];
+  provider?: MainProvider;
+  // Legacy support - will be deprecated
+  providers?: LegacyProvider[];
   enableOpenApi?: boolean;
 }
 
@@ -19,6 +61,35 @@ export interface RouteInfo {
   handler: string;
 }
 
+export interface FunctionInfo {
+  name: string;
+  handler: string;
+  timeout?: number;
+  memorySize?: number;
+}
+
+export interface CronInfo {
+  name: string;
+  handler: string;
+  schedule: string;
+  timeout?: number;
+  memorySize?: number;
+}
+
 export interface RoutesManifest {
   routes: RouteInfo[];
 }
+
+export interface FunctionsManifest {
+  functions: FunctionInfo[];
+}
+
+export interface CronsManifest {
+  crons: CronInfo[];
+}
+
+export interface BuildManifest {
+  routes: RouteInfo[];
+  functions: FunctionInfo[];
+  crons: CronInfo[];
+}

package/dist/build-BTggTCYL.cjs

@@ -1,176 +0,0 @@
-const require_chunk = require('./chunk-CUT6urMc.cjs');
-const require_config = require('./config-BNqUMsvc.cjs');
-const require_loadEndpoints = require('./loadEndpoints-BBIavB9h.cjs');
-const node_fs_promises = require_chunk.__toESM(require("node:fs/promises"));
-const path = require_chunk.__toESM(require("path"));
-
-//#region src/build.ts
-const logger = console;
-async function buildCommand(options) {
-	logger.log(`Building with providers: ${options.providers.join(", ")}`);
-	const config = await require_config.loadConfig();
-	logger.log(`Loading routes from: ${config.routes}`);
-	logger.log(`Using envParser: ${config.envParser}`);
-	const [envParserPath, envParserName] = config.envParser.split("#");
-	const envParserImportPattern = !envParserName ? "envParser" : envParserName === "envParser" ? "{ envParser }" : `{ ${envParserName} as envParser }`;
-	const [loggerPath, loggerName] = config.logger.split("#");
-	const loggerImportPattern = !loggerName ? "logger" : loggerName === "logger" ? "{ logger }" : `{ ${loggerName} as logger }`;
-	const loadedEndpoints = await require_loadEndpoints.loadEndpoints(config.routes);
-	if (loadedEndpoints.length === 0) {
-		logger.log("No endpoints found to process");
-		return;
-	}
-	const allEndpoints = loadedEndpoints.map(({ name, endpoint, file }) => {
-		const routeInfo = {
-			path: endpoint._path,
-			method: endpoint.method,
-			handler: ""
-		};
-		logger.log(`Found endpoint: ${name} - ${routeInfo.method} ${routeInfo.path}`);
-		return {
-			file: (0, path.relative)(process.cwd(), file),
-			exportName: name,
-			endpoint,
-			routeInfo
-		};
-	});
-	for (const provider of options.providers) {
-		const routes = [];
-		const outputDir = (0, path.join)(process.cwd(), ".gkm", provider);
-		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, options.enableOpenApi || false);
-			routes.push({
-				path: "*",
-				method: "ALL",
-				handler: (0, path.relative)(process.cwd(), serverFile)
-			});
-			logger.log(`Generated server app with ${allEndpoints.length} endpoints${options.enableOpenApi ? " (OpenAPI enabled)" : ""}`);
-		} else for (const { file, exportName, routeInfo } of allEndpoints) {
-			const handlerFile = await generateHandlerFile(outputDir, file, exportName, provider, routeInfo, envParserPath, envParserImportPattern);
-			routes.push({
-				...routeInfo,
-				handler: (0, path.relative)(process.cwd(), handlerFile).replace(/\.ts$/, ".handler")
-			});
-			logger.log(`Generated handler for ${routeInfo.method} ${routeInfo.path}`);
-		}
-		const manifest = { routes };
-		const manifestPath = (0, path.join)(outputDir, "routes.json");
-		await (0, node_fs_promises.writeFile)(manifestPath, JSON.stringify(manifest, null, 2));
-		logger.log(`Generated ${routes.length} handlers in ${(0, path.relative)(process.cwd(), outputDir)}`);
-		logger.log(`Routes manifest: ${(0, path.relative)(process.cwd(), manifestPath)}`);
-	}
-}
-async function generateServerFile(outputDir, endpoints, envParserPath, envParserImportPattern, loggerPath, loggerImportPattern, enableOpenApi) {
-	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");
-		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 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';
-import { Endpoint } from '@geekmidas/api/server';
-import { ServiceDiscovery } from '@geekmidas/api/services';
-import { Hono } from 'hono';
-import ${envParserImportPattern} from '${relativeEnvParserPath}';
-import ${loggerImportPattern} from '${relativeLoggerPath}';
-${imports}
-
-export function createApp(app?: Hono, enableOpenApi: boolean = ${enableOpenApi}): Hono {
-  const honoApp = app || new Hono();
-  
-  const endpoints: Endpoint<any, any, any, any, any, any, any>[] = [
-    ${allExportNames.join(",\n    ")}
-  ];
-
-  const serviceDiscovery = ServiceDiscovery.getInstance(
-    logger,
-    envParser
-  );
-
-  // Configure OpenAPI options based on enableOpenApi flag
-  const openApiOptions: any = enableOpenApi ? {
-    docsPath: '/docs',
-    openApiOptions: {
-      title: 'API Documentation',
-      version: '1.0.0',
-      description: 'Generated API documentation'
-    }
-  } : { docsPath: false };
-
-  HonoEndpoint.addRoutes(endpoints, serviceDiscovery, honoApp, openApiOptions);
-
-  return honoApp;
-}
-
-// Default export for convenience
-export default createApp;
-`;
-	await (0, node_fs_promises.writeFile)(serverPath, content);
-	return serverPath;
-}
-async function generateHandlerFile(outputDir, sourceFile, exportName, provider, _routeInfo, envParserPath, envParserImportPattern) {
-	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);
-	let content;
-	switch (provider) {
-		case "aws-apigatewayv1":
-			content = generateAWSApiGatewayV1Handler(importPath, exportName, relativeEnvParserPath, envParserImportPattern);
-			break;
-		case "aws-apigatewayv2":
-			content = generateAWSApiGatewayV2Handler(importPath, exportName, relativeEnvParserPath, envParserImportPattern);
-			break;
-		case "server":
-			content = generateServerHandler(importPath, exportName);
-			break;
-		default: throw new Error(`Unsupported provider: ${provider}`);
-	}
-	await (0, node_fs_promises.writeFile)(handlerPath, content);
-	return handlerPath;
-}
-function generateAWSApiGatewayV1Handler(importPath, exportName, envParserPath, envParserImportPattern) {
-	return `import { AmazonApiGatewayV1Endpoint } from '@geekmidas/api/aws-apigateway';
-import { ${exportName} } from '${importPath}';
-import ${envParserImportPattern} from '${envParserPath}';
-
-const adapter = new AmazonApiGatewayV1Endpoint(envParser, ${exportName});
-
-export const handler = adapter.handler;
-`;
-}
-function generateAWSApiGatewayV2Handler(importPath, exportName, envParserPath, envParserImportPattern) {
-	return `import { AmazonApiGatewayV2Endpoint } from '@geekmidas/api/aws-apigateway';
-import { ${exportName} } from '${importPath}';
-import ${envParserImportPattern} from '${envParserPath}';
-
-const adapter = new AmazonApiGatewayV2Endpoint(envParser, ${exportName});
-
-export const handler = adapter.handler;
-`;
-}
-function generateServerHandler(importPath, exportName) {
-	return `import { ${exportName} } from '${importPath}';
-
-// Server handler - implement based on your server framework
-export const handler = ${exportName};
-`;
-}
-
-//#endregion
-Object.defineProperty(exports, 'buildCommand', {
-  enumerable: true,
-  get: function () {
-    return buildCommand;
-  }
-});

package/dist/build-Ca4P6_lY.mjs

@@ -1,170 +0,0 @@
-import { loadConfig } from "./config-BciAdY6_.mjs";
-import { loadEndpoints } from "./loadEndpoints-DAZ53Og2.mjs";
-import { mkdir, writeFile } from "node:fs/promises";
-import { dirname, join, relative } from "path";
-
-//#region src/build.ts
-const logger = console;
-async function buildCommand(options) {
-	logger.log(`Building with providers: ${options.providers.join(", ")}`);
-	const config = await loadConfig();
-	logger.log(`Loading routes from: ${config.routes}`);
-	logger.log(`Using envParser: ${config.envParser}`);
-	const [envParserPath, envParserName] = config.envParser.split("#");
-	const envParserImportPattern = !envParserName ? "envParser" : envParserName === "envParser" ? "{ envParser }" : `{ ${envParserName} as envParser }`;
-	const [loggerPath, loggerName] = config.logger.split("#");
-	const loggerImportPattern = !loggerName ? "logger" : loggerName === "logger" ? "{ logger }" : `{ ${loggerName} as logger }`;
-	const loadedEndpoints = await loadEndpoints(config.routes);
-	if (loadedEndpoints.length === 0) {
-		logger.log("No endpoints found to process");
-		return;
-	}
-	const allEndpoints = loadedEndpoints.map(({ name, endpoint, file }) => {
-		const routeInfo = {
-			path: endpoint._path,
-			method: endpoint.method,
-			handler: ""
-		};
-		logger.log(`Found endpoint: ${name} - ${routeInfo.method} ${routeInfo.path}`);
-		return {
-			file: relative(process.cwd(), file),
-			exportName: name,
-			endpoint,
-			routeInfo
-		};
-	});
-	for (const provider of options.providers) {
-		const routes = [];
-		const outputDir = join(process.cwd(), ".gkm", provider);
-		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, options.enableOpenApi || false);
-			routes.push({
-				path: "*",
-				method: "ALL",
-				handler: relative(process.cwd(), serverFile)
-			});
-			logger.log(`Generated server app with ${allEndpoints.length} endpoints${options.enableOpenApi ? " (OpenAPI enabled)" : ""}`);
-		} else for (const { file, exportName, routeInfo } of allEndpoints) {
-			const handlerFile = await generateHandlerFile(outputDir, file, exportName, provider, routeInfo, envParserPath, envParserImportPattern);
-			routes.push({
-				...routeInfo,
-				handler: relative(process.cwd(), handlerFile).replace(/\.ts$/, ".handler")
-			});
-			logger.log(`Generated handler for ${routeInfo.method} ${routeInfo.path}`);
-		}
-		const manifest = { routes };
-		const manifestPath = join(outputDir, "routes.json");
-		await writeFile(manifestPath, JSON.stringify(manifest, null, 2));
-		logger.log(`Generated ${routes.length} handlers in ${relative(process.cwd(), outputDir)}`);
-		logger.log(`Routes manifest: ${relative(process.cwd(), manifestPath)}`);
-	}
-}
-async function generateServerFile(outputDir, endpoints, envParserPath, envParserImportPattern, loggerPath, loggerImportPattern, enableOpenApi) {
-	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");
-		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 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';
-import { Endpoint } from '@geekmidas/api/server';
-import { ServiceDiscovery } from '@geekmidas/api/services';
-import { Hono } from 'hono';
-import ${envParserImportPattern} from '${relativeEnvParserPath}';
-import ${loggerImportPattern} from '${relativeLoggerPath}';
-${imports}
-
-export function createApp(app?: Hono, enableOpenApi: boolean = ${enableOpenApi}): Hono {
-  const honoApp = app || new Hono();
-  
-  const endpoints: Endpoint<any, any, any, any, any, any, any>[] = [
-    ${allExportNames.join(",\n    ")}
-  ];
-
-  const serviceDiscovery = ServiceDiscovery.getInstance(
-    logger,
-    envParser
-  );
-
-  // Configure OpenAPI options based on enableOpenApi flag
-  const openApiOptions: any = enableOpenApi ? {
-    docsPath: '/docs',
-    openApiOptions: {
-      title: 'API Documentation',
-      version: '1.0.0',
-      description: 'Generated API documentation'
-    }
-  } : { docsPath: false };
-
-  HonoEndpoint.addRoutes(endpoints, serviceDiscovery, honoApp, openApiOptions);
-
-  return honoApp;
-}
-
-// Default export for convenience
-export default createApp;
-`;
-	await writeFile(serverPath, content);
-	return serverPath;
-}
-async function generateHandlerFile(outputDir, sourceFile, exportName, provider, _routeInfo, envParserPath, envParserImportPattern) {
-	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);
-	let content;
-	switch (provider) {
-		case "aws-apigatewayv1":
-			content = generateAWSApiGatewayV1Handler(importPath, exportName, relativeEnvParserPath, envParserImportPattern);
-			break;
-		case "aws-apigatewayv2":
-			content = generateAWSApiGatewayV2Handler(importPath, exportName, relativeEnvParserPath, envParserImportPattern);
-			break;
-		case "server":
-			content = generateServerHandler(importPath, exportName);
-			break;
-		default: throw new Error(`Unsupported provider: ${provider}`);
-	}
-	await writeFile(handlerPath, content);
-	return handlerPath;
-}
-function generateAWSApiGatewayV1Handler(importPath, exportName, envParserPath, envParserImportPattern) {
-	return `import { AmazonApiGatewayV1Endpoint } from '@geekmidas/api/aws-apigateway';
-import { ${exportName} } from '${importPath}';
-import ${envParserImportPattern} from '${envParserPath}';
-
-const adapter = new AmazonApiGatewayV1Endpoint(envParser, ${exportName});
-
-export const handler = adapter.handler;
-`;
-}
-function generateAWSApiGatewayV2Handler(importPath, exportName, envParserPath, envParserImportPattern) {
-	return `import { AmazonApiGatewayV2Endpoint } from '@geekmidas/api/aws-apigateway';
-import { ${exportName} } from '${importPath}';
-import ${envParserImportPattern} from '${envParserPath}';
-
-const adapter = new AmazonApiGatewayV2Endpoint(envParser, ${exportName});
-
-export const handler = adapter.handler;
-`;
-}
-function generateServerHandler(importPath, exportName) {
-	return `import { ${exportName} } from '${importPath}';
-
-// Server handler - implement based on your server framework
-export const handler = ${exportName};
-`;
-}
-
-//#endregion
-export { buildCommand };

package/dist/build.cjs

@@ -1,5 +0,0 @@
-require('./config-BNqUMsvc.cjs');
-require('./loadEndpoints-BBIavB9h.cjs');
-const require_build = require('./build-BTggTCYL.cjs');
-
-exports.buildCommand = require_build.buildCommand;

package/dist/build.mjs

@@ -1,5 +0,0 @@
-import "./config-BciAdY6_.mjs";
-import "./loadEndpoints-DAZ53Og2.mjs";
-import { buildCommand } from "./build-Ca4P6_lY.mjs";
-
-export { buildCommand };

package/dist/config-BNqUMsvc.cjs

@@ -1,24 +0,0 @@
-const require_chunk = require('./chunk-CUT6urMc.cjs');
-const path = require_chunk.__toESM(require("path"));
-const fs = require_chunk.__toESM(require("fs"));
-const fs_promises = require_chunk.__toESM(require("fs/promises"));
-
-//#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 (0, fs_promises.readFile)(configPath, "utf-8");
-		return JSON.parse(config);
-	} catch (error) {
-		throw new Error(`Failed to load gkm.config.json: ${error.message}`);
-	}
-}
-
-//#endregion
-Object.defineProperty(exports, 'loadConfig', {
-  enumerable: true,
-  get: function () {
-    return loadConfig;
-  }
-});

package/dist/config-BciAdY6_.mjs

@@ -1,18 +0,0 @@
-import { join } from "path";
-import { existsSync } from "fs";
-import { readFile } from "fs/promises";
-
-//#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 readFile(configPath, "utf-8");
-		return JSON.parse(config);
-	} catch (error) {
-		throw new Error(`Failed to load gkm.config.json: ${error.message}`);
-	}
-}
-
-//#endregion
-export { loadConfig };

package/dist/loadEndpoints-BBIavB9h.cjs

@@ -1,37 +0,0 @@
-const require_chunk = require('./chunk-CUT6urMc.cjs');
-const __geekmidas_api_server = require_chunk.__toESM(require("@geekmidas/api/server"));
-const fast_glob = require_chunk.__toESM(require("fast-glob"));
-
-//#region src/loadEndpoints.ts
-async function loadEndpoints(routes) {
-	const logger = console;
-	const files = await fast_glob.default.stream(routes, {
-		cwd: process.cwd(),
-		absolute: true
-	});
-	const endpoints = [];
-	for await (const f of files) try {
-		const file = f.toString();
-		const module$1 = await import(file);
-		for (const [exportName, exportValue] of Object.entries(module$1)) if (__geekmidas_api_server.Endpoint.isEndpoint(exportValue)) {
-			exportValue.operationId = exportName;
-			endpoints.push({
-				name: exportName,
-				endpoint: exportValue,
-				file
-			});
-		}
-	} catch (error) {
-		logger.warn(`Failed to load ${f}:`, error.message);
-		throw new Error("Failed to load endpoints. Please check the logs for details.");
-	}
-	return endpoints;
-}
-
-//#endregion
-Object.defineProperty(exports, 'loadEndpoints', {
-  enumerable: true,
-  get: function () {
-    return loadEndpoints;
-  }
-});