@geekmidas/cli 9.0.2 → 10.0.0-alpha.1

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

@@ -1,235 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { CachedStateProvider } from '../CachedStateProvider';
-import type { StateProvider } from '../StateProvider';
-import type { DokployStageState } from '../state';
-
-const createMockProvider = (): StateProvider & {
-	readCalls: string[];
-	writeCalls: Array<{ stage: string; state: DokployStageState }>;
-	storage: Map<string, DokployStageState>;
-} => {
-	const storage = new Map<string, DokployStageState>();
-	const readCalls: string[] = [];
-	const writeCalls: Array<{ stage: string; state: DokployStageState }> = [];
-
-	return {
-		storage,
-		readCalls,
-		writeCalls,
-		async read(stage: string): Promise<DokployStageState | null> {
-			readCalls.push(stage);
-			return storage.get(stage) ?? null;
-		},
-		async write(stage: string, state: DokployStageState): Promise<void> {
-			writeCalls.push({ stage, state });
-			storage.set(stage, { ...state });
-		},
-	};
-};
-
-describe('CachedStateProvider', () => {
-	describe('read', () => {
-		it('should return local state if available', async () => {
-			const local = createMockProvider();
-			const remote = createMockProvider();
-
-			const state: DokployStageState = {
-				provider: 'dokploy',
-				stage: 'production',
-				projectId: 'proj_test',
-				environmentId: 'env_123',
-				applications: { api: 'local_app' },
-				services: {},
-				lastDeployedAt: '2024-01-01T00:00:00.000Z',
-			};
-			local.storage.set('production', state);
-
-			const cached = new CachedStateProvider(remote, local);
-			const result = await cached.read('production');
-
-			expect(result).toEqual(state);
-			expect(local.readCalls).toEqual(['production']);
-			expect(remote.readCalls).toEqual([]);
-		});
-
-		it('should fetch from remote and cache locally if local missing', async () => {
-			const local = createMockProvider();
-			const remote = createMockProvider();
-
-			const state: DokployStageState = {
-				provider: 'dokploy',
-				stage: 'production',
-				projectId: 'proj_test',
-				environmentId: 'env_123',
-				applications: { api: 'remote_app' },
-				services: {},
-				lastDeployedAt: '2024-01-01T00:00:00.000Z',
-			};
-			remote.storage.set('production', state);
-
-			const cached = new CachedStateProvider(remote, local);
-			const result = await cached.read('production');
-
-			expect(result).toEqual(state);
-			expect(local.readCalls).toEqual(['production']);
-			expect(remote.readCalls).toEqual(['production']);
-			expect(local.writeCalls.length).toBe(1);
-			expect(local.writeCalls[0].stage).toBe('production');
-		});
-
-		it('should return null if both local and remote are empty', async () => {
-			const local = createMockProvider();
-			const remote = createMockProvider();
-
-			const cached = new CachedStateProvider(remote, local);
-			const result = await cached.read('nonexistent');
-
-			expect(result).toBeNull();
-			expect(local.readCalls).toEqual(['nonexistent']);
-			expect(remote.readCalls).toEqual(['nonexistent']);
-		});
-	});
-
-	describe('write', () => {
-		it('should write to both remote and local', async () => {
-			const local = createMockProvider();
-			const remote = createMockProvider();
-
-			const state: DokployStageState = {
-				provider: 'dokploy',
-				stage: 'production',
-				projectId: 'proj_test',
-				environmentId: 'env_123',
-				applications: { api: 'app_123' },
-				services: {},
-				lastDeployedAt: '2024-01-01T00:00:00.000Z',
-			};
-
-			const cached = new CachedStateProvider(remote, local);
-			await cached.write('production', state);
-
-			expect(remote.writeCalls.length).toBe(1);
-			expect(remote.writeCalls[0].stage).toBe('production');
-			expect(local.writeCalls.length).toBe(1);
-			expect(local.writeCalls[0].stage).toBe('production');
-		});
-	});
-
-	describe('pull', () => {
-		it('should fetch from remote and update local', async () => {
-			const local = createMockProvider();
-			const remote = createMockProvider();
-
-			const remoteState: DokployStageState = {
-				provider: 'dokploy',
-				stage: 'production',
-				projectId: 'proj_test',
-				environmentId: 'env_123',
-				applications: { api: 'remote_app' },
-				services: {},
-				lastDeployedAt: '2024-01-01T00:00:00.000Z',
-			};
-			remote.storage.set('production', remoteState);
-
-			const cached = new CachedStateProvider(remote, local);
-			const result = await cached.pull('production');
-
-			expect(result).toEqual(remoteState);
-			expect(remote.readCalls).toEqual(['production']);
-			expect(local.writeCalls.length).toBe(1);
-		});
-
-		it('should return null if remote is empty', async () => {
-			const local = createMockProvider();
-			const remote = createMockProvider();
-
-			const cached = new CachedStateProvider(remote, local);
-			const result = await cached.pull('nonexistent');
-
-			expect(result).toBeNull();
-			expect(local.writeCalls.length).toBe(0);
-		});
-	});
-
-	describe('push', () => {
-		it('should push local state to remote', async () => {
-			const local = createMockProvider();
-			const remote = createMockProvider();
-
-			const localState: DokployStageState = {
-				provider: 'dokploy',
-				stage: 'production',
-				projectId: 'proj_test',
-				environmentId: 'env_123',
-				applications: { api: 'local_app' },
-				services: {},
-				lastDeployedAt: '2024-01-01T00:00:00.000Z',
-			};
-			local.storage.set('production', localState);
-
-			const cached = new CachedStateProvider(remote, local);
-			const result = await cached.push('production');
-
-			expect(result).toEqual(localState);
-			expect(local.readCalls).toEqual(['production']);
-			expect(remote.writeCalls.length).toBe(1);
-		});
-
-		it('should return null if local is empty', async () => {
-			const local = createMockProvider();
-			const remote = createMockProvider();
-
-			const cached = new CachedStateProvider(remote, local);
-			const result = await cached.push('nonexistent');
-
-			expect(result).toBeNull();
-			expect(remote.writeCalls.length).toBe(0);
-		});
-	});
-
-	describe('diff', () => {
-		it('should return both local and remote state', async () => {
-			const local = createMockProvider();
-			const remote = createMockProvider();
-
-			const localState: DokployStageState = {
-				provider: 'dokploy',
-				stage: 'production',
-				projectId: 'proj_test',
-				environmentId: 'env_123',
-				applications: { api: 'local_app' },
-				services: {},
-				lastDeployedAt: '2024-01-01T00:00:00.000Z',
-			};
-			const remoteState: DokployStageState = {
-				provider: 'dokploy',
-				stage: 'production',
-				projectId: 'proj_test',
-				environmentId: 'env_123',
-				applications: { api: 'remote_app' },
-				services: {},
-				lastDeployedAt: '2024-01-02T00:00:00.000Z',
-			};
-
-			local.storage.set('production', localState);
-			remote.storage.set('production', remoteState);
-
-			const cached = new CachedStateProvider(remote, local);
-			const result = await cached.diff('production');
-
-			expect(result.local).toEqual(localState);
-			expect(result.remote).toEqual(remoteState);
-		});
-
-		it('should handle missing states', async () => {
-			const local = createMockProvider();
-			const remote = createMockProvider();
-
-			const cached = new CachedStateProvider(remote, local);
-			const result = await cached.diff('nonexistent');
-
-			expect(result.local).toBeNull();
-			expect(result.remote).toBeNull();
-		});
-	});
-});

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

@@ -1,347 +0,0 @@
-import { HttpResponse, http } from 'msw';
-import { setupServer } from 'msw/node';
-import {
-	afterAll,
-	afterEach,
-	beforeAll,
-	beforeEach,
-	describe,
-	expect,
-	it,
-} from 'vitest';
-import { HostingerProvider } from '../dns/HostingerProvider';
-
-/**
- * HostingerProvider Tests
- *
- * Uses MSW to mock the Hostinger DNS API.
- * API Base: https://developers.hostinger.com
- */
-describe('HostingerProvider', () => {
-	const HOSTINGER_API_BASE = 'https://developers.hostinger.com';
-	const TEST_DOMAIN = 'example.com';
-	const TEST_TOKEN = 'test-hostinger-token';
-
-	// Track current mock records for realistic API simulation
-	let mockRecords: Array<{
-		name: string;
-		type: string;
-		ttl: number;
-		records: Array<{ content: string }>;
-	}> = [];
-
-	// MSW server setup
-	const server = setupServer(
-		// GET /api/dns/v1/zones/{domain} - Get DNS records
-		http.get(
-			`${HOSTINGER_API_BASE}/api/dns/v1/zones/:domain`,
-			({ request }) => {
-				// Check authorization
-				const authHeader = request.headers.get('Authorization');
-				if (authHeader !== `Bearer ${TEST_TOKEN}`) {
-					return HttpResponse.json(
-						{ message: 'Unauthorized' },
-						{ status: 401 },
-					);
-				}
-
-				return HttpResponse.json({ data: mockRecords });
-			},
-		),
-
-		// PUT /api/dns/v1/zones/{domain} - Upsert DNS records
-		http.put(
-			`${HOSTINGER_API_BASE}/api/dns/v1/zones/:domain`,
-			async ({ request }) => {
-				// Check authorization
-				const authHeader = request.headers.get('Authorization');
-				if (authHeader !== `Bearer ${TEST_TOKEN}`) {
-					return HttpResponse.json(
-						{ message: 'Unauthorized' },
-						{ status: 401 },
-					);
-				}
-
-				const body = (await request.json()) as {
-					overwrite?: boolean;
-					zone: Array<{
-						name: string;
-						type: string;
-						ttl: number;
-						records: Array<{ content: string }>;
-					}>;
-				};
-
-				// Simulate upsert behavior
-				for (const record of body.zone) {
-					const existingIndex = mockRecords.findIndex(
-						(r) => r.name === record.name && r.type === record.type,
-					);
-					if (existingIndex >= 0) {
-						mockRecords[existingIndex] = record;
-					} else {
-						mockRecords.push(record);
-					}
-				}
-
-				return new HttpResponse(null, { status: 204 });
-			},
-		),
-	);
-
-	beforeAll(() => {
-		// Set the token via environment variable
-		process.env.HOSTINGER_API_TOKEN = TEST_TOKEN;
-		server.listen({ onUnhandledRequest: 'error' });
-	});
-
-	beforeEach(() => {
-		// Reset mock records before each test
-		mockRecords = [];
-	});
-
-	afterEach(() => {
-		server.resetHandlers();
-	});
-
-	afterAll(() => {
-		delete process.env.HOSTINGER_API_TOKEN;
-		server.close();
-	});
-
-	describe('name', () => {
-		it('should have name "hostinger"', () => {
-			const provider = new HostingerProvider();
-			expect(provider.name).toBe('hostinger');
-		});
-	});
-
-	describe('getRecords', () => {
-		it('should throw error when token is invalid', async () => {
-			// Use an invalid token
-			const savedToken = process.env.HOSTINGER_API_TOKEN;
-			process.env.HOSTINGER_API_TOKEN = 'invalid-token';
-
-			try {
-				const provider = new HostingerProvider();
-				await expect(provider.getRecords(TEST_DOMAIN)).rejects.toThrow(
-					'Hostinger API error',
-				);
-			} finally {
-				// Restore the token
-				process.env.HOSTINGER_API_TOKEN = savedToken;
-			}
-		});
-
-		it('should return empty array when no records exist', async () => {
-			const provider = new HostingerProvider();
-			const records = await provider.getRecords(TEST_DOMAIN);
-
-			expect(records).toEqual([]);
-		});
-
-		it('should return records from API', async () => {
-			// Set up mock records
-			mockRecords = [
-				{
-					name: 'api',
-					type: 'A',
-					ttl: 300,
-					records: [{ content: '1.2.3.4' }],
-				},
-				{
-					name: 'www',
-					type: 'CNAME',
-					ttl: 300,
-					records: [{ content: 'example.com' }],
-				},
-			];
-
-			const provider = new HostingerProvider();
-			const records = await provider.getRecords(TEST_DOMAIN);
-
-			expect(records).toHaveLength(2);
-			expect(records[0]).toEqual({
-				name: 'api',
-				type: 'A',
-				ttl: 300,
-				values: ['1.2.3.4'],
-			});
-			expect(records[1]).toEqual({
-				name: 'www',
-				type: 'CNAME',
-				ttl: 300,
-				values: ['example.com'],
-			});
-		});
-
-		it('should handle records with multiple values', async () => {
-			mockRecords = [
-				{
-					name: 'mail',
-					type: 'MX',
-					ttl: 3600,
-					records: [
-						{ content: '10 mail1.example.com' },
-						{ content: '20 mail2.example.com' },
-					],
-				},
-			];
-
-			const provider = new HostingerProvider();
-			const records = await provider.getRecords(TEST_DOMAIN);
-
-			expect(records).toHaveLength(1);
-			expect(records[0]?.values).toEqual([
-				'10 mail1.example.com',
-				'20 mail2.example.com',
-			]);
-		});
-
-		it('should cache API client after first call', async () => {
-			const provider = new HostingerProvider();
-
-			// Make two calls
-			await provider.getRecords(TEST_DOMAIN);
-			await provider.getRecords(TEST_DOMAIN);
-
-			// Both should succeed (API client is reused internally)
-			// If caching wasn't working, we'd see issues with token retrieval
-			expect(true).toBe(true);
-		});
-	});
-
-	describe('upsertRecords', () => {
-		it('should create new records', async () => {
-			const provider = new HostingerProvider();
-			const results = await provider.upsertRecords(TEST_DOMAIN, [
-				{ name: 'api', type: 'A', ttl: 300, value: '1.2.3.4' },
-			]);
-
-			expect(results).toHaveLength(1);
-			expect(results[0]).toEqual({
-				record: { name: 'api', type: 'A', ttl: 300, value: '1.2.3.4' },
-				created: true,
-				unchanged: false,
-			});
-
-			// Verify record was added to mock store
-			expect(mockRecords).toHaveLength(1);
-			expect(mockRecords[0]).toEqual({
-				name: 'api',
-				type: 'A',
-				ttl: 300,
-				records: [{ content: '1.2.3.4' }],
-			});
-		});
-
-		it('should mark unchanged when record exists with same value', async () => {
-			// Pre-populate with existing record
-			mockRecords = [
-				{
-					name: 'api',
-					type: 'A',
-					ttl: 300,
-					records: [{ content: '1.2.3.4' }],
-				},
-			];
-
-			const provider = new HostingerProvider();
-			const results = await provider.upsertRecords(TEST_DOMAIN, [
-				{ name: 'api', type: 'A', ttl: 300, value: '1.2.3.4' },
-			]);
-
-			expect(results).toHaveLength(1);
-			expect(results[0]).toEqual({
-				record: { name: 'api', type: 'A', ttl: 300, value: '1.2.3.4' },
-				created: false,
-				unchanged: true,
-			});
-		});
-
-		it('should update record when value changes', async () => {
-			// Pre-populate with existing record
-			mockRecords = [
-				{
-					name: 'api',
-					type: 'A',
-					ttl: 300,
-					records: [{ content: '1.2.3.4' }],
-				},
-			];
-
-			const provider = new HostingerProvider();
-			const results = await provider.upsertRecords(TEST_DOMAIN, [
-				{ name: 'api', type: 'A', ttl: 300, value: '5.6.7.8' },
-			]);
-
-			expect(results).toHaveLength(1);
-			expect(results[0]).toEqual({
-				record: { name: 'api', type: 'A', ttl: 300, value: '5.6.7.8' },
-				created: false,
-				unchanged: false,
-			});
-
-			// Verify record was updated in mock store
-			expect(mockRecords[0]?.records[0]?.content).toBe('5.6.7.8');
-		});
-
-		it('should handle multiple records with mixed states', async () => {
-			// Pre-populate with one existing record
-			mockRecords = [
-				{
-					name: 'api',
-					type: 'A',
-					ttl: 300,
-					records: [{ content: '1.2.3.4' }],
-				},
-			];
-
-			const provider = new HostingerProvider();
-			const results = await provider.upsertRecords(TEST_DOMAIN, [
-				{ name: 'api', type: 'A', ttl: 300, value: '1.2.3.4' }, // Unchanged
-				{ name: 'www', type: 'A', ttl: 300, value: '1.2.3.4' }, // New
-			]);
-
-			expect(results).toHaveLength(2);
-			expect(results[0]?.unchanged).toBe(true);
-			expect(results[1]?.created).toBe(true);
-
-			// Verify both records exist in mock store
-			expect(mockRecords).toHaveLength(2);
-		});
-	});
-
-	describe('API error handling', () => {
-		it('should handle API errors gracefully', async () => {
-			// Override the handler to return an error
-			server.use(
-				http.get(`${HOSTINGER_API_BASE}/api/dns/v1/zones/:domain`, () => {
-					return HttpResponse.json(
-						{ message: 'Domain not found' },
-						{ status: 404 },
-					);
-				}),
-			);
-
-			const provider = new HostingerProvider();
-
-			await expect(provider.getRecords(TEST_DOMAIN)).rejects.toThrow(
-				'Hostinger API error',
-			);
-		});
-
-		it('should handle network errors', async () => {
-			// Override the handler to simulate network error
-			server.use(
-				http.get(`${HOSTINGER_API_BASE}/api/dns/v1/zones/:domain`, () => {
-					return HttpResponse.error();
-				}),
-			);
-
-			const provider = new HostingerProvider();
-
-			await expect(provider.getRecords(TEST_DOMAIN)).rejects.toThrow();
-		});
-	});
-});

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

@@ -1,130 +0,0 @@
-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 { LocalStateProvider } from '../LocalStateProvider';
-import type { DokployStageState } from '../state';
-
-describe('LocalStateProvider', () => {
-	let testDir: string;
-	let provider: LocalStateProvider;
-
-	beforeEach(async () => {
-		testDir = join(tmpdir(), `gkm-local-state-test-${Date.now()}`);
-		await mkdir(testDir, { recursive: true });
-		provider = new LocalStateProvider(testDir);
-	});
-
-	afterEach(async () => {
-		await rm(testDir, { recursive: true, force: true });
-	});
-
-	describe('read', () => {
-		it('should return null when state file does not exist', async () => {
-			const state = await provider.read('nonexistent');
-			expect(state).toBeNull();
-		});
-
-		it('should read existing state file', async () => {
-			const stateData: DokployStageState = {
-				provider: 'dokploy',
-				stage: 'production',
-				projectId: 'proj_test',
-				environmentId: 'env_123',
-				applications: { api: 'app_123' },
-				services: { postgresId: 'pg_123' },
-				lastDeployedAt: '2024-01-01T00:00:00.000Z',
-			};
-
-			await mkdir(join(testDir, '.gkm'), { recursive: true });
-			await writeFile(
-				join(testDir, '.gkm', 'deploy-production.json'),
-				JSON.stringify(stateData),
-			);
-
-			const state = await provider.read('production');
-			expect(state).toEqual(stateData);
-		});
-
-		it('should return null for invalid JSON', async () => {
-			await mkdir(join(testDir, '.gkm'), { recursive: true });
-			await writeFile(
-				join(testDir, '.gkm', 'deploy-invalid.json'),
-				'not valid json',
-			);
-
-			const state = await provider.read('invalid');
-			expect(state).toBeNull();
-		});
-	});
-
-	describe('write', () => {
-		it('should create .gkm directory if not exists', async () => {
-			const state: DokployStageState = {
-				provider: 'dokploy',
-				stage: 'staging',
-				projectId: 'proj_test',
-				environmentId: 'env_456',
-				applications: {},
-				services: {},
-				lastDeployedAt: '2024-01-01T00:00:00.000Z',
-			};
-
-			await provider.write('staging', state);
-
-			const content = await readFile(
-				join(testDir, '.gkm', 'deploy-staging.json'),
-				'utf-8',
-			);
-			expect(JSON.parse(content).stage).toBe('staging');
-		});
-
-		it('should update lastDeployedAt timestamp', async () => {
-			const state: DokployStageState = {
-				provider: 'dokploy',
-				stage: 'staging',
-				projectId: 'proj_test',
-				environmentId: 'env_456',
-				applications: {},
-				services: {},
-				lastDeployedAt: '2024-01-01T00:00:00.000Z',
-			};
-
-			const originalTimestamp = state.lastDeployedAt;
-			await new Promise((resolve) => setTimeout(resolve, 10));
-			await provider.write('staging', state);
-
-			expect(state.lastDeployedAt).not.toBe(originalTimestamp);
-		});
-
-		it('should preserve state data', async () => {
-			const state: DokployStageState = {
-				provider: 'dokploy',
-				stage: 'production',
-				projectId: 'proj_test',
-				environmentId: 'env_123',
-				applications: { api: 'app_123', web: 'app_456' },
-				services: { postgresId: 'pg_123', redisId: 'redis_123' },
-				appCredentials: { api: { dbUser: 'api', dbPassword: 'secret' } },
-				lastDeployedAt: '2024-01-01T00:00:00.000Z',
-			};
-
-			await provider.write('production', state);
-
-			const content = await readFile(
-				join(testDir, '.gkm', 'deploy-production.json'),
-				'utf-8',
-			);
-			const parsed = JSON.parse(content);
-
-			expect(parsed.applications).toEqual({ api: 'app_123', web: 'app_456' });
-			expect(parsed.services).toEqual({
-				postgresId: 'pg_123',
-				redisId: 'redis_123',
-			});
-			expect(parsed.appCredentials).toEqual({
-				api: { dbUser: 'api', dbPassword: 'secret' },
-			});
-		});
-	});
-});