@geekmidas/cli 0.53.0 → 1.0.0

package/src/deploy/__tests__/sniffer.spec.ts

@@ -5,6 +5,7 @@ import type { NormalizedAppConfig } from '../../workspace/types';
 import {
 	_sniffEntryFile,
 	_sniffEnvParser,
+	_sniffRouteFiles,
 	sniffAllApps,
 	sniffAppEnvironment,
 } from '../sniffer';
@@ -13,6 +14,7 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const fixturesPath = resolve(__dirname, '__fixtures__/entry-apps');
 const envParserFixturesPath = resolve(__dirname, '__fixtures__/env-parsers');
+const routeAppsFixturesPath = resolve(__dirname, '__fixtures__/route-apps');
 
 describe('sniffAppEnvironment', () => {
 	const workspacePath = '/test/workspace';
@@ -489,11 +491,7 @@ describe('sniffAppEnvironment with envParser apps', () => {
 			envParser: './valid-env-parser.ts#envParser',
 		};
 
-		const result = await sniffAppEnvironment(
-			app,
-			'api',
-			envParserFixturesPath,
-		);
+		const result = await sniffAppEnvironment(app, 'api', envParserFixturesPath);
 
 		expect(result.appName).toBe('api');
 		expect(result.requiredEnvVars).toContain('PORT');
@@ -512,11 +510,7 @@ describe('sniffAppEnvironment with envParser apps', () => {
 			requiredEnv: ['CUSTOM_VAR'], // Should use this instead
 		};
 
-		const result = await sniffAppEnvironment(
-			app,
-			'api',
-			envParserFixturesPath,
-		);
+		const result = await sniffAppEnvironment(app, 'api', envParserFixturesPath);
 
 		expect(result.requiredEnvVars).toEqual(['CUSTOM_VAR']);
 		// Should NOT contain the sniffed vars
@@ -544,3 +538,167 @@ describe('sniffAppEnvironment with envParser apps', () => {
 		expect(result.requiredEnvVars).toEqual([]);
 	});
 });
+
+describe('route files sniffing via _sniffRouteFiles', () => {
+	// These tests verify the route-based sniffing for apps with routes config.
+	// Each test uses fixture files that export endpoints with services.
+
+	it('should sniff environment variables from endpoint with single service', async () => {
+		const result = await _sniffRouteFiles(
+			'./endpoints/users.ts',
+			routeAppsFixturesPath,
+			routeAppsFixturesPath,
+		);
+
+		expect(result.envVars).toContain('DATABASE_URL');
+		// DB_POOL_SIZE is optional, may or may not be captured
+		expect(result.error).toBeUndefined();
+	});
+
+	it('should sniff environment variables from endpoint with multiple services', async () => {
+		const result = await _sniffRouteFiles(
+			'./endpoints/auth.ts',
+			routeAppsFixturesPath,
+			routeAppsFixturesPath,
+		);
+
+		expect(result.envVars).toContain('DATABASE_URL');
+		expect(result.envVars).toContain('AUTH_SECRET');
+		expect(result.envVars).toContain('AUTH_URL');
+		expect(result.error).toBeUndefined();
+	});
+
+	it('should return empty for endpoint without services', async () => {
+		const result = await _sniffRouteFiles(
+			'./endpoints/health.ts',
+			routeAppsFixturesPath,
+			routeAppsFixturesPath,
+		);
+
+		expect(result.envVars).toEqual([]);
+		expect(result.error).toBeUndefined();
+	});
+
+	it('should sniff all endpoints matching glob pattern', async () => {
+		const result = await _sniffRouteFiles(
+			'./endpoints/**/*.ts',
+			routeAppsFixturesPath,
+			routeAppsFixturesPath,
+		);
+
+		// Should capture env vars from all endpoints
+		expect(result.envVars).toContain('DATABASE_URL');
+		expect(result.envVars).toContain('AUTH_SECRET');
+		expect(result.envVars).toContain('AUTH_URL');
+		expect(result.error).toBeUndefined();
+	});
+
+	it('should return empty for non-existent pattern', async () => {
+		const result = await _sniffRouteFiles(
+			'./nonexistent/**/*.ts',
+			routeAppsFixturesPath,
+			routeAppsFixturesPath,
+		);
+
+		expect(result.envVars).toEqual([]);
+		expect(result.error).toBeUndefined();
+	});
+
+	it('should handle array of patterns', async () => {
+		const result = await _sniffRouteFiles(
+			['./endpoints/users.ts', './endpoints/health.ts'],
+			routeAppsFixturesPath,
+			routeAppsFixturesPath,
+		);
+
+		expect(result.envVars).toContain('DATABASE_URL');
+		expect(result.error).toBeUndefined();
+	});
+
+	it('should deduplicate env vars from multiple endpoints using same service', async () => {
+		const result = await _sniffRouteFiles(
+			['./endpoints/users.ts', './endpoints/auth.ts'],
+			routeAppsFixturesPath,
+			routeAppsFixturesPath,
+		);
+
+		// DATABASE_URL is used by both endpoints, should only appear once
+		const databaseUrlCount = result.envVars.filter(
+			(v) => v === 'DATABASE_URL',
+		).length;
+		expect(databaseUrlCount).toBe(1);
+	});
+
+	it('should return sorted env vars', async () => {
+		const result = await _sniffRouteFiles(
+			'./endpoints/**/*.ts',
+			routeAppsFixturesPath,
+			routeAppsFixturesPath,
+		);
+
+		const sorted = [...result.envVars].sort();
+		expect(result.envVars).toEqual(sorted);
+	});
+});
+
+describe('sniffAppEnvironment with route-based apps', () => {
+	// Integration tests for sniffAppEnvironment with route-based apps
+
+	it('should use route sniffing for apps with routes config', async () => {
+		const app: NormalizedAppConfig = {
+			type: 'backend',
+			path: routeAppsFixturesPath,
+			port: 3000,
+			dependencies: [],
+			resolvedDeployTarget: 'dokploy',
+			routes: './endpoints/**/*.ts',
+			envParser: './src/config/env#envParser', // Should be ignored when routes exist
+		};
+
+		const result = await sniffAppEnvironment(app, 'api', routeAppsFixturesPath);
+
+		expect(result.appName).toBe('api');
+		expect(result.requiredEnvVars).toContain('DATABASE_URL');
+		expect(result.requiredEnvVars).toContain('AUTH_SECRET');
+		expect(result.requiredEnvVars).toContain('AUTH_URL');
+	});
+
+	it('should prefer requiredEnv over route sniffing', async () => {
+		const app: NormalizedAppConfig = {
+			type: 'backend',
+			path: routeAppsFixturesPath,
+			port: 3000,
+			dependencies: [],
+			resolvedDeployTarget: 'dokploy',
+			routes: './endpoints/**/*.ts',
+			requiredEnv: ['CUSTOM_VAR'], // Should use this instead
+		};
+
+		const result = await sniffAppEnvironment(app, 'api', routeAppsFixturesPath);
+
+		expect(result.requiredEnvVars).toEqual(['CUSTOM_VAR']);
+		// Should NOT contain the sniffed vars
+		expect(result.requiredEnvVars).not.toContain('DATABASE_URL');
+	});
+
+	it('should handle route pattern that matches no files', async () => {
+		const app: NormalizedAppConfig = {
+			type: 'backend',
+			path: routeAppsFixturesPath,
+			port: 3000,
+			dependencies: [],
+			resolvedDeployTarget: 'dokploy',
+			routes: './nonexistent/**/*.ts',
+		};
+
+		const result = await sniffAppEnvironment(
+			app,
+			'api',
+			routeAppsFixturesPath,
+			{ logWarnings: false },
+		);
+
+		expect(result.appName).toBe('api');
+		expect(result.requiredEnvVars).toEqual([]);
+	});
+});

package/src/deploy/__tests__/state.spec.ts

@@ -2,6 +2,7 @@ import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import type { DokployStageState } from '../state';
 import {
 	createEmptyState,
 	getAllAppCredentials,
@@ -24,7 +25,6 @@ import {
 	setRedisId,
 	writeStageState,
 } from '../state';
-import type { DokployStageState } from '../state';
 
 describe('state management', () => {
 	let testDir: string;
@@ -423,7 +423,9 @@ describe('state management', () => {
 				lastDeployedAt: '2024-01-01T00:00:00.000Z',
 			};
 
-			expect(getGeneratedSecret(state, 'api', 'BETTER_AUTH_SECRET')).toBeUndefined();
+			expect(
+				getGeneratedSecret(state, 'api', 'BETTER_AUTH_SECRET'),
+			).toBeUndefined();
 		});
 
 		it('should return undefined when secret name not found', () => {
@@ -445,11 +447,15 @@ describe('state management', () => {
 		it('should return undefined when no generatedSecrets', () => {
 			const state = createEmptyState('production', 'env_123');
 
-			expect(getGeneratedSecret(state, 'auth', 'BETTER_AUTH_SECRET')).toBeUndefined();
+			expect(
+				getGeneratedSecret(state, 'auth', 'BETTER_AUTH_SECRET'),
+			).toBeUndefined();
 		});
 
 		it('should return undefined when state is null', () => {
-			expect(getGeneratedSecret(null, 'auth', 'BETTER_AUTH_SECRET')).toBeUndefined();
+			expect(
+				getGeneratedSecret(null, 'auth', 'BETTER_AUTH_SECRET'),
+			).toBeUndefined();
 		});
 	});
 
@@ -459,7 +465,9 @@ describe('state management', () => {
 
 			setGeneratedSecret(state, 'auth', 'BETTER_AUTH_SECRET', 'secret123');
 
-			expect(state.generatedSecrets?.auth?.BETTER_AUTH_SECRET).toBe('secret123');
+			expect(state.generatedSecrets?.auth?.BETTER_AUTH_SECRET).toBe(
+				'secret123',
+			);
 		});
 
 		it('should initialize generatedSecrets if not exists', () => {

package/src/deploy/dns/DnsProvider.ts

@@ -0,0 +1,163 @@
+/**
+ * DNS Provider Interface
+ *
+ * Abstracts DNS operations for different providers.
+ * Built-in providers: HostingerProvider, Route53Provider
+ * Users can also supply custom implementations.
+ */
+
+import type { z } from 'zod/v4';
+import type {
+	CloudflareDnsProviderSchema,
+	CustomDnsProviderSchema,
+	DnsProviderSchema,
+	DnsRecordSchema,
+	DnsRecordTypeSchema,
+	HostingerDnsProviderSchema,
+	ManualDnsProviderSchema,
+	Route53DnsProviderSchema,
+	UpsertDnsRecordSchema,
+	UpsertResultSchema,
+} from '../../workspace/schema';
+
+// =============================================================================
+// DNS Record Types (derived from Zod schemas)
+// =============================================================================
+
+/**
+ * DNS record types supported across providers.
+ */
+export type DnsRecordType = z.infer<typeof DnsRecordTypeSchema>;
+
+/**
+ * A DNS record as returned by the provider.
+ */
+export type DnsRecord = z.infer<typeof DnsRecordSchema>;
+
+/**
+ * A DNS record to create or update.
+ */
+export type UpsertDnsRecord = z.infer<typeof UpsertDnsRecordSchema>;
+
+/**
+ * Result of an upsert operation.
+ */
+export type UpsertResult = z.infer<typeof UpsertResultSchema>;
+
+// =============================================================================
+// DNS Provider Interface
+// =============================================================================
+
+/**
+ * Interface for DNS providers.
+ *
+ * Implementations must handle:
+ * - Getting all records for a domain
+ * - Creating or updating records for a domain
+ */
+export interface DnsProvider {
+	/** Provider name for logging */
+	readonly name: string;
+
+	/**
+	 * Get all DNS records for a domain.
+	 *
+	 * @param domain - Root domain (e.g., 'example.com')
+	 * @returns Array of DNS records
+	 */
+	getRecords(domain: string): Promise<DnsRecord[]>;
+
+	/**
+	 * Create or update DNS records.
+	 *
+	 * @param domain - Root domain (e.g., 'example.com')
+	 * @param records - Records to create or update
+	 * @returns Results of the upsert operations
+	 */
+	upsertRecords(
+		domain: string,
+		records: UpsertDnsRecord[],
+	): Promise<UpsertResult[]>;
+}
+
+// =============================================================================
+// DNS Provider Config Types (derived from Zod schemas)
+// =============================================================================
+
+export type HostingerDnsConfig = z.infer<typeof HostingerDnsProviderSchema>;
+export type Route53DnsConfig = z.infer<typeof Route53DnsProviderSchema>;
+export type CloudflareDnsConfig = z.infer<typeof CloudflareDnsProviderSchema>;
+export type ManualDnsConfig = z.infer<typeof ManualDnsProviderSchema>;
+export type CustomDnsConfig = z.infer<typeof CustomDnsProviderSchema>;
+/** Single DNS provider config (for one domain) */
+export type DnsConfig = z.infer<typeof DnsProviderSchema>;
+
+// =============================================================================
+// DNS Provider Factory
+// =============================================================================
+
+/**
+ * Check if value is a DnsProvider implementation.
+ */
+export function isDnsProvider(value: unknown): value is DnsProvider {
+	return (
+		typeof value === 'object' &&
+		value !== null &&
+		typeof (value as DnsProvider).name === 'string' &&
+		typeof (value as DnsProvider).getRecords === 'function' &&
+		typeof (value as DnsProvider).upsertRecords === 'function'
+	);
+}
+
+export interface CreateDnsProviderOptions {
+	/** DNS config from workspace */
+	config: DnsConfig;
+}
+
+/**
+ * Create a DNS provider based on configuration.
+ *
+ * - 'hostinger': HostingerProvider
+ * - 'route53': Route53Provider
+ * - 'manual': Returns null (user handles DNS)
+ * - Custom: Use provided DnsProvider implementation
+ */
+export async function createDnsProvider(
+	options: CreateDnsProviderOptions,
+): Promise<DnsProvider | null> {
+	const { config } = options;
+
+	// Manual mode - no provider needed
+	if (config.provider === 'manual') {
+		return null;
+	}
+
+	// Custom provider implementation
+	if (isDnsProvider(config.provider)) {
+		return config.provider;
+	}
+
+	// Built-in providers
+	const provider = config.provider;
+
+	if (provider === 'hostinger') {
+		const { HostingerProvider } = await import('./HostingerProvider');
+		return new HostingerProvider();
+	}
+
+	if (provider === 'route53') {
+		const { Route53Provider } = await import('./Route53Provider');
+		const route53Config = config as Route53DnsConfig;
+		return new Route53Provider({
+			region: route53Config.region,
+			profile: route53Config.profile,
+			hostedZoneId: route53Config.hostedZoneId,
+		});
+	}
+
+	if (provider === 'cloudflare') {
+		throw new Error('Cloudflare DNS provider not yet implemented');
+	}
+
+	throw new Error(`Unknown DNS provider: ${JSON.stringify(config)}`);
+}

package/src/deploy/dns/HostingerProvider.ts

@@ -0,0 +1,100 @@
+/**
+ * Hostinger DNS Provider
+ *
+ * Implements DnsProvider interface using the Hostinger DNS API.
+ */
+
+import { getHostingerToken } from '../../auth/credentials';
+import type {
+	DnsProvider,
+	DnsRecord,
+	UpsertDnsRecord,
+	UpsertResult,
+} from './DnsProvider';
+import { HostingerApi } from './hostinger-api';
+
+/**
+ * Hostinger DNS provider implementation.
+ */
+export class HostingerProvider implements DnsProvider {
+	readonly name = 'hostinger';
+	private api: HostingerApi | null = null;
+
+	/**
+	 * Get or create the Hostinger API client.
+	 */
+	private async getApi(): Promise<HostingerApi> {
+		if (this.api) {
+			return this.api;
+		}
+
+		const token = await getHostingerToken();
+		if (!token) {
+			throw new Error(
+				'Hostinger API token not configured. Run `gkm login --service=hostinger` or get your token from https://hpanel.hostinger.com/profile/api',
+			);
+		}
+
+		this.api = new HostingerApi(token);
+		return this.api;
+	}
+
+	async getRecords(domain: string): Promise<DnsRecord[]> {
+		const api = await this.getApi();
+		const records = await api.getRecords(domain);
+
+		return records.map((r) => ({
+			name: r.name,
+			type: r.type,
+			ttl: r.ttl,
+			values: r.records.map((rec) => rec.content),
+		}));
+	}
+
+	async upsertRecords(
+		domain: string,
+		records: UpsertDnsRecord[],
+	): Promise<UpsertResult[]> {
+		const api = await this.getApi();
+		const results: UpsertResult[] = [];
+
+		// Get existing records to check what already exists
+		const existingRecords = await api.getRecords(domain);
+
+		for (const record of records) {
+			const existing = existingRecords.find(
+				(r) => r.name === record.name && r.type === record.type,
+			);
+
+			const existingValue = existing?.records?.[0]?.content;
+
+			if (existing && existingValue === record.value) {
+				// Record exists with same value - unchanged
+				results.push({
+					record,
+					created: false,
+					unchanged: true,
+				});
+				continue;
+			}
+
+			// Create or update the record
+			await api.upsertRecords(domain, [
+				{
+					name: record.name,
+					type: record.type,
+					ttl: record.ttl,
+					records: [{ content: record.value }],
+				},
+			]);
+
+			results.push({
+				record,
+				created: !existing,
+				unchanged: false,
+			});
+		}
+
+		return results;
+	}
+}