@geekmidas/cli 2.0.2 → 10.0.0-alpha.0

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

@@ -1,195 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-	createDnsProvider,
-	type DeleteDnsRecord,
-	type DeleteResult,
-	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 () => [],
-			deleteRecords: 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 [];
-				},
-				async deleteRecords(
-					_domain: string,
-					records: DeleteDnsRecord[],
-				): Promise<DeleteResult[]> {
-					return records.map((r) => ({
-						record: r,
-						deleted: true,
-						notFound: false,
-					}));
-				},
-			};
-
-			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,
-					}));
-				},
-				async deleteRecords(
-					_domain: string,
-					records: DeleteDnsRecord[],
-				): Promise<DeleteResult[]> {
-					return records.map((r) => ({
-						record: r,
-						deleted: true,
-						notFound: 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

@@ -1,126 +0,0 @@
-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);
-		});
-
-		it('should create CachedStateProvider for ssm config with profile', async () => {
-			const provider = await createStateProvider({
-				config: { provider: 'ssm', region: 'us-east-1', profile: 'my-profile' },
-				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

@@ -1,192 +0,0 @@
-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');
-		});
-	});
-});