@geekmidas/cli 0.53.0 → 1.0.0

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

@@ -0,0 +1,172 @@
+import { describe, expect, it } from 'vitest';
+import {
+	createDnsProvider,
+	type DnsProvider,
+	type DnsRecord,
+	isDnsProvider,
+	type UpsertDnsRecord,
+	type UpsertResult,
+} from '../dns/DnsProvider';
+
+describe('isDnsProvider', () => {
+	it('should return true for valid provider', () => {
+		const provider: DnsProvider = {
+			name: 'test',
+			getRecords: async () => [],
+			upsertRecords: async () => [],
+		};
+		expect(isDnsProvider(provider)).toBe(true);
+	});
+
+	it('should return false for null', () => {
+		expect(isDnsProvider(null)).toBe(false);
+	});
+
+	it('should return false for undefined', () => {
+		expect(isDnsProvider(undefined)).toBe(false);
+	});
+
+	it('should return false for empty object', () => {
+		expect(isDnsProvider({})).toBe(false);
+	});
+
+	it('should return false for object with only name', () => {
+		expect(isDnsProvider({ name: 'test' })).toBe(false);
+	});
+
+	it('should return false for object with only getRecords', () => {
+		expect(isDnsProvider({ getRecords: () => [] })).toBe(false);
+	});
+
+	it('should return false for object with only upsertRecords', () => {
+		expect(isDnsProvider({ upsertRecords: () => [] })).toBe(false);
+	});
+
+	it('should return false for object with name and getRecords only', () => {
+		expect(isDnsProvider({ name: 'test', getRecords: () => [] })).toBe(false);
+	});
+
+	it('should return false for object with non-string name', () => {
+		expect(
+			isDnsProvider({
+				name: 123,
+				getRecords: () => [],
+				upsertRecords: () => [],
+			}),
+		).toBe(false);
+	});
+});
+
+describe('createDnsProvider', () => {
+	describe('manual provider', () => {
+		it('should return null for manual provider', async () => {
+			const provider = await createDnsProvider({
+				config: { provider: 'manual' },
+			});
+
+			expect(provider).toBeNull();
+		});
+	});
+
+	describe('hostinger provider', () => {
+		it('should create HostingerProvider for hostinger config', async () => {
+			const provider = await createDnsProvider({
+				config: { provider: 'hostinger' },
+			});
+
+			expect(provider).not.toBeNull();
+			expect(provider?.name).toBe('hostinger');
+		});
+	});
+
+	describe('route53 provider', () => {
+		it('should create Route53Provider for route53 config', async () => {
+			const provider = await createDnsProvider({
+				config: {
+					provider: 'route53',
+					region: 'us-east-1',
+				},
+			});
+
+			expect(provider).not.toBeNull();
+			expect(provider?.name).toBe('route53');
+		});
+
+		it('should create Route53Provider with hostedZoneId', async () => {
+			const provider = await createDnsProvider({
+				config: {
+					provider: 'route53',
+					region: 'us-west-2',
+					hostedZoneId: 'Z1234567890',
+				},
+			});
+
+			expect(provider).not.toBeNull();
+			expect(provider?.name).toBe('route53');
+		});
+	});
+
+	describe('cloudflare provider', () => {
+		it('should throw for cloudflare provider (not yet implemented)', async () => {
+			await expect(
+				createDnsProvider({
+					config: { provider: 'cloudflare' },
+				}),
+			).rejects.toThrow('Cloudflare DNS provider not yet implemented');
+		});
+	});
+
+	describe('custom provider', () => {
+		it('should use custom provider implementation', async () => {
+			const customProvider: DnsProvider = {
+				name: 'custom-test',
+				async getRecords(): Promise<DnsRecord[]> {
+					return [];
+				},
+				async upsertRecords(): Promise<UpsertResult[]> {
+					return [];
+				},
+			};
+
+			const provider = await createDnsProvider({
+				config: {
+					provider: customProvider,
+				},
+			});
+
+			expect(provider).toBe(customProvider);
+		});
+
+		it('should use custom provider with getRecords that returns data', async () => {
+			const mockRecords: DnsRecord[] = [
+				{ name: 'api', type: 'A', ttl: 300, values: ['1.2.3.4'] },
+			];
+
+			const customProvider: DnsProvider = {
+				name: 'custom-test',
+				async getRecords(): Promise<DnsRecord[]> {
+					return mockRecords;
+				},
+				async upsertRecords(
+					_domain: string,
+					records: UpsertDnsRecord[],
+				): Promise<UpsertResult[]> {
+					return records.map((r) => ({
+						record: r,
+						created: true,
+						unchanged: false,
+					}));
+				},
+			};
+
+			const provider = await createDnsProvider({
+				config: {
+					provider: customProvider,
+				},
+			});
+
+			const records = await provider!.getRecords('example.com');
+			expect(records).toEqual(mockRecords);
+		});
+	});
+});

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

@@ -0,0 +1,116 @@
+import { mkdir, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { CachedStateProvider } from '../CachedStateProvider';
+import { LocalStateProvider } from '../LocalStateProvider';
+import {
+	createStateProvider,
+	isStateProvider,
+	type StateProvider,
+} from '../StateProvider';
+
+describe('createStateProvider', () => {
+	let testDir: string;
+
+	beforeEach(async () => {
+		testDir = join(tmpdir(), `gkm-state-factory-test-${Date.now()}`);
+		await mkdir(testDir, { recursive: true });
+	});
+
+	afterEach(async () => {
+		await rm(testDir, { recursive: true, force: true });
+	});
+
+	describe('isStateProvider', () => {
+		it('should return true for valid provider', () => {
+			const provider = {
+				read: async () => null,
+				write: async () => {},
+			};
+			expect(isStateProvider(provider)).toBe(true);
+		});
+
+		it('should return false for null', () => {
+			expect(isStateProvider(null)).toBe(false);
+		});
+
+		it('should return false for undefined', () => {
+			expect(isStateProvider(undefined)).toBe(false);
+		});
+
+		it('should return false for empty object', () => {
+			expect(isStateProvider({})).toBe(false);
+		});
+
+		it('should return false for object with only read', () => {
+			expect(isStateProvider({ read: () => {} })).toBe(false);
+		});
+
+		it('should return false for object with only write', () => {
+			expect(isStateProvider({ write: () => {} })).toBe(false);
+		});
+	});
+
+	describe('local provider', () => {
+		it('should create LocalStateProvider when no config', async () => {
+			const provider = await createStateProvider({
+				workspaceRoot: testDir,
+				workspaceName: 'test',
+			});
+
+			expect(provider).toBeInstanceOf(LocalStateProvider);
+		});
+
+		it('should create LocalStateProvider when provider is local', async () => {
+			const provider = await createStateProvider({
+				config: { provider: 'local' },
+				workspaceRoot: testDir,
+				workspaceName: 'test',
+			});
+
+			expect(provider).toBeInstanceOf(LocalStateProvider);
+		});
+	});
+
+	describe('ssm provider', () => {
+		it('should throw when workspace name is missing', async () => {
+			await expect(
+				createStateProvider({
+					config: { provider: 'ssm', region: 'us-east-1' },
+					workspaceRoot: testDir,
+					workspaceName: '',
+				}),
+			).rejects.toThrow('Workspace name is required');
+		});
+
+		it('should create CachedStateProvider for ssm config', async () => {
+			const provider = await createStateProvider({
+				config: { provider: 'ssm', region: 'us-east-1' },
+				workspaceRoot: testDir,
+				workspaceName: 'test-workspace',
+			});
+
+			expect(provider).toBeInstanceOf(CachedStateProvider);
+		});
+	});
+
+	describe('custom provider', () => {
+		it('should use custom provider implementation', async () => {
+			const customProvider: StateProvider = {
+				async read(): Promise<null> {
+					return null;
+				},
+				async write(): Promise<void> {},
+			};
+
+			const provider = await createStateProvider({
+				config: { provider: customProvider },
+				workspaceRoot: testDir,
+				workspaceName: 'test',
+			});
+
+			expect(provider).toBe(customProvider);
+		});
+	});
+});

package/src/deploy/__tests__/dns-orchestration.spec.ts

@@ -0,0 +1,192 @@
+import { describe, expect, it } from 'vitest';
+import {
+	extractSubdomain,
+	findRootDomain,
+	generateRequiredRecords,
+	groupHostnamesByDomain,
+	isLegacyDnsConfig,
+	normalizeDnsConfig,
+} from '../dns/index';
+
+describe('DNS orchestration helpers', () => {
+	describe('isLegacyDnsConfig', () => {
+		it('should return true for legacy config with domain property', () => {
+			const config = { provider: 'hostinger', domain: 'example.com' };
+			expect(isLegacyDnsConfig(config)).toBe(true);
+		});
+
+		it('should return false for new multi-domain config', () => {
+			const config = {
+				'example.com': { provider: 'hostinger' },
+				'example.dev': { provider: 'route53' },
+			};
+			expect(isLegacyDnsConfig(config)).toBe(false);
+		});
+
+		it('should return false for config without domain property', () => {
+			const config = { provider: 'hostinger' };
+			expect(isLegacyDnsConfig(config)).toBe(false);
+		});
+	});
+
+	describe('normalizeDnsConfig', () => {
+		it('should convert legacy config to multi-domain format', () => {
+			const config = { provider: 'hostinger', domain: 'example.com', ttl: 300 };
+			const normalized = normalizeDnsConfig(config);
+
+			expect(normalized).toEqual({
+				'example.com': { provider: 'hostinger', ttl: 300 },
+			});
+		});
+
+		it('should pass through multi-domain config unchanged', () => {
+			const config = {
+				'example.com': { provider: 'hostinger' },
+				'example.dev': { provider: 'route53' },
+			};
+			const normalized = normalizeDnsConfig(config);
+
+			expect(normalized).toBe(config);
+		});
+	});
+
+	describe('findRootDomain', () => {
+		const dnsConfig = {
+			'traflabs.io': { provider: 'hostinger' as const },
+			'geekmidas.com': { provider: 'route53' as const },
+			'sub.geekmidas.com': { provider: 'manual' as const },
+		};
+
+		it('should find exact domain match', () => {
+			expect(findRootDomain('traflabs.io', dnsConfig)).toBe('traflabs.io');
+		});
+
+		it('should find root domain for subdomain', () => {
+			expect(findRootDomain('api.traflabs.io', dnsConfig)).toBe('traflabs.io');
+		});
+
+		it('should find root domain for nested subdomain', () => {
+			expect(findRootDomain('staging.api.traflabs.io', dnsConfig)).toBe(
+				'traflabs.io',
+			);
+		});
+
+		it('should prefer more specific domain', () => {
+			expect(findRootDomain('api.sub.geekmidas.com', dnsConfig)).toBe(
+				'sub.geekmidas.com',
+			);
+		});
+
+		it('should return null for unknown domain', () => {
+			expect(findRootDomain('unknown.com', dnsConfig)).toBeNull();
+		});
+
+		it('should return null for domain that is prefix but not subdomain', () => {
+			// 'exampletraflabs.io' should not match 'traflabs.io'
+			expect(findRootDomain('exampletraflabs.io', dnsConfig)).toBeNull();
+		});
+	});
+
+	describe('groupHostnamesByDomain', () => {
+		const dnsConfig = {
+			'traflabs.io': { provider: 'hostinger' as const },
+			'geekmidas.com': { provider: 'route53' as const },
+		};
+
+		it('should group hostnames by their root domain', () => {
+			const appHostnames = new Map([
+				['api', 'api.traflabs.io'],
+				['web', 'web.traflabs.io'],
+				['docs', 'docs.geekmidas.com'],
+			]);
+
+			const grouped = groupHostnamesByDomain(appHostnames, dnsConfig);
+
+			expect(grouped.size).toBe(2);
+			expect(grouped.get('traflabs.io')?.size).toBe(2);
+			expect(grouped.get('traflabs.io')?.get('api')).toBe('api.traflabs.io');
+			expect(grouped.get('traflabs.io')?.get('web')).toBe('web.traflabs.io');
+			expect(grouped.get('geekmidas.com')?.size).toBe(1);
+			expect(grouped.get('geekmidas.com')?.get('docs')).toBe(
+				'docs.geekmidas.com',
+			);
+		});
+
+		it('should skip hostnames without matching domain', () => {
+			const appHostnames = new Map([
+				['api', 'api.traflabs.io'],
+				['unknown', 'api.unknown.com'],
+			]);
+
+			const grouped = groupHostnamesByDomain(appHostnames, dnsConfig);
+
+			expect(grouped.size).toBe(1);
+			expect(grouped.get('traflabs.io')?.size).toBe(1);
+		});
+	});
+
+	describe('extractSubdomain', () => {
+		it('should extract single-level subdomain', () => {
+			expect(extractSubdomain('api.example.com', 'example.com')).toBe('api');
+		});
+
+		it('should extract multi-level subdomain', () => {
+			expect(extractSubdomain('staging.api.example.com', 'example.com')).toBe(
+				'staging.api',
+			);
+		});
+
+		it('should return @ for root domain', () => {
+			expect(extractSubdomain('example.com', 'example.com')).toBe('@');
+		});
+
+		it('should throw for hostname not under root domain', () => {
+			expect(() => extractSubdomain('api.other.com', 'example.com')).toThrow(
+				'not under root domain',
+			);
+		});
+	});
+
+	describe('generateRequiredRecords', () => {
+		it('should generate A records for all app hostnames', () => {
+			const appHostnames = new Map([
+				['api', 'api.example.com'],
+				['web', 'web.example.com'],
+			]);
+
+			const records = generateRequiredRecords(
+				appHostnames,
+				'example.com',
+				'1.2.3.4',
+			);
+
+			expect(records).toHaveLength(2);
+			expect(records[0]).toMatchObject({
+				hostname: 'api.example.com',
+				subdomain: 'api',
+				type: 'A',
+				value: '1.2.3.4',
+				appName: 'api',
+			});
+			expect(records[1]).toMatchObject({
+				hostname: 'web.example.com',
+				subdomain: 'web',
+				type: 'A',
+				value: '1.2.3.4',
+				appName: 'web',
+			});
+		});
+
+		it('should handle nested subdomains', () => {
+			const appHostnames = new Map([['api', 'staging.api.example.com']]);
+
+			const records = generateRequiredRecords(
+				appHostnames,
+				'example.com',
+				'1.2.3.4',
+			);
+
+			expect(records[0]?.subdomain).toBe('staging.api');
+		});
+	});
+});

package/src/deploy/__tests__/dns-verification.spec.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { createEmptyState, type DokployStageState } from '../state';
 
 // Mock dns/promises lookup
@@ -8,7 +8,7 @@ vi.mock('node:dns/promises', () => ({
 
 // Import after mocking
 import { lookup } from 'node:dns/promises';
-import { verifyDnsRecords, resolveHostnameToIp } from '../dns/index';
+import { resolveHostnameToIp, verifyDnsRecords } from '../dns/index';
 
 describe('resolveHostnameToIp', () => {
 	const mockLookup = vi.mocked(lookup);

package/src/deploy/__tests__/env-resolver.spec.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it, vi } from 'vitest';
+import { describe, expect, it } from 'vitest';
 import type { NormalizedAppConfig } from '../../workspace/types';
 import {
 	AUTO_SUPPORTED_VARS,
@@ -151,7 +151,11 @@ describe('buildRedisUrl', () => {
 	});
 
 	it('should encode special characters in password', () => {
-		const redis = { host: 'redis.example.com', port: 6380, password: 'p@ss:word' };
+		const redis = {
+			host: 'redis.example.com',
+			port: 6380,
+			password: 'p@ss:word',
+		};
 
 		const url = buildRedisUrl(redis);
 
@@ -191,16 +195,18 @@ describe('resolveEnvVar', () => {
 		expect(resolveEnvVar('PORT', context)).toBe('8080');
 	});
 
-	it('should resolve NODE_ENV based on stage', () => {
-		expect(resolveEnvVar('NODE_ENV', createContext({ stage: 'production' }))).toBe(
-			'production',
-		);
+	it('should resolve NODE_ENV to production for all stages (deployed apps)', () => {
+		// NODE_ENV is always 'production' for deployed apps
+		// gkm dev handles development mode separately
+		expect(
+			resolveEnvVar('NODE_ENV', createContext({ stage: 'production' })),
+		).toBe('production');
 		expect(resolveEnvVar('NODE_ENV', createContext({ stage: 'staging' }))).toBe(
-			'development',
-		);
-		expect(resolveEnvVar('NODE_ENV', createContext({ stage: 'development' }))).toBe(
-			'development',
+			'production',
 		);
+		expect(
+			resolveEnvVar('NODE_ENV', createContext({ stage: 'development' })),
+		).toBe('production');
 	});
 
 	it('should resolve DATABASE_URL when credentials and postgres are provided', () => {
@@ -241,7 +247,9 @@ describe('resolveEnvVar', () => {
 	it('should resolve BETTER_AUTH_URL from app hostname', () => {
 		const context = createContext({ appHostname: 'auth.myapp.com' });
 
-		expect(resolveEnvVar('BETTER_AUTH_URL', context)).toBe('https://auth.myapp.com');
+		expect(resolveEnvVar('BETTER_AUTH_URL', context)).toBe(
+			'https://auth.myapp.com',
+		);
 	});
 
 	it('should resolve BETTER_AUTH_SECRET by generating and storing secret', () => {
@@ -267,7 +275,9 @@ describe('resolveEnvVar', () => {
 	it('should return undefined for BETTER_AUTH_TRUSTED_ORIGINS when no frontend URLs', () => {
 		const context = createContext({ frontendUrls: [] });
 
-		expect(resolveEnvVar('BETTER_AUTH_TRUSTED_ORIGINS', context)).toBeUndefined();
+		expect(
+			resolveEnvVar('BETTER_AUTH_TRUSTED_ORIGINS', context),
+		).toBeUndefined();
 	});
 
 	it('should resolve GKM_MASTER_KEY from context', () => {
@@ -364,7 +374,10 @@ describe('resolveEnvVars', () => {
 			postgres: { host: 'postgres', port: 5432, database: 'mydb' },
 		});
 
-		const result = resolveEnvVars(['PORT', 'NODE_ENV', 'DATABASE_URL'], context);
+		const result = resolveEnvVars(
+			['PORT', 'NODE_ENV', 'DATABASE_URL'],
+			context,
+		);
 
 		expect(result.resolved).toEqual({
 			PORT: '3000',
@@ -398,12 +411,20 @@ describe('resolveEnvVars', () => {
 
 describe('formatMissingVarsError', () => {
 	it('should format error message with missing variables', () => {
-		const error = formatMissingVarsError('api', ['DATABASE_URL', 'REDIS_URL'], 'production');
+		const error = formatMissingVarsError(
+			'api',
+			['DATABASE_URL', 'REDIS_URL'],
+			'production',
+		);
 
-		expect(error).toContain('Deployment failed: api is missing required environment variables');
+		expect(error).toContain(
+			'Deployment failed: api is missing required environment variables',
+		);
 		expect(error).toContain('- DATABASE_URL');
 		expect(error).toContain('- REDIS_URL');
-		expect(error).toContain('gkm secrets:set <VAR_NAME> <value> --stage production');
+		expect(error).toContain(
+			'gkm secrets:set <VAR_NAME> <value> --stage production',
+		);
 	});
 
 	it('should handle single missing variable', () => {
@@ -450,7 +471,10 @@ describe('validateEnvVars', () => {
 	it('should return valid=false when vars are missing', () => {
 		const context = createContext();
 
-		const result = validateEnvVars(['PORT', 'DATABASE_URL', 'CUSTOM_VAR'], context);
+		const result = validateEnvVars(
+			['PORT', 'DATABASE_URL', 'CUSTOM_VAR'],
+			context,
+		);
 
 		expect(result.valid).toBe(false);
 		expect(result.missing).toEqual(['DATABASE_URL', 'CUSTOM_VAR']);