@geekmidas/cli 2.0.2 → 10.0.0-alpha.0

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

@@ -1,435 +0,0 @@
-import { HttpResponse, http } from 'msw';
-import { setupServer } from 'msw/node';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { deployDokploy, validateDokployConfig } from '../dokploy';
-import { generateTag } from '../index';
-import type { DokployDeployConfig } from '../types';
-
-// Mock auth functions
-vi.mock('../../auth', () => ({
-	getDokployToken: vi.fn().mockResolvedValue('test-api-token'),
-	getDokployRegistryId: vi.fn().mockResolvedValue(null),
-}));
-
-// MSW server for mocking Dokploy API
-const server = setupServer();
-
-describe('validateDokployConfig', () => {
-	it('should return true for valid complete config', () => {
-		const config: DokployDeployConfig = {
-			endpoint: 'https://dokploy.example.com',
-			projectId: 'proj_123',
-			applicationId: 'app_456',
-		};
-
-		const result = validateDokployConfig(config);
-		expect(result).toBe(true);
-	});
-
-	it('should return true with optional registry', () => {
-		const config: DokployDeployConfig = {
-			endpoint: 'https://dokploy.example.com',
-			projectId: 'proj_123',
-			applicationId: 'app_456',
-			registry: 'ghcr.io/myorg',
-		};
-
-		const result = validateDokployConfig(config);
-		expect(result).toBe(true);
-	});
-
-	it('should return false for undefined config', () => {
-		const result = validateDokployConfig(undefined);
-		expect(result).toBe(false);
-	});
-
-	it('should throw for missing endpoint', () => {
-		const config = {
-			projectId: 'proj_123',
-			applicationId: 'app_456',
-		} as Partial<DokployDeployConfig>;
-
-		expect(() => validateDokployConfig(config)).toThrow(
-			'Missing Dokploy configuration: endpoint',
-		);
-	});
-
-	it('should throw for missing projectId', () => {
-		const config = {
-			endpoint: 'https://dokploy.example.com',
-			applicationId: 'app_456',
-		} as Partial<DokployDeployConfig>;
-
-		expect(() => validateDokployConfig(config)).toThrow(
-			'Missing Dokploy configuration: projectId',
-		);
-	});
-
-	it('should throw for missing applicationId', () => {
-		const config = {
-			endpoint: 'https://dokploy.example.com',
-			projectId: 'proj_123',
-		} as Partial<DokployDeployConfig>;
-
-		expect(() => validateDokployConfig(config)).toThrow(
-			'Missing Dokploy configuration: applicationId',
-		);
-	});
-
-	it('should list all missing fields', () => {
-		const config = {
-			endpoint: 'https://dokploy.example.com',
-		} as Partial<DokployDeployConfig>;
-
-		expect(() => validateDokployConfig(config)).toThrow(
-			'Missing Dokploy configuration: projectId, applicationId',
-		);
-	});
-
-	it('should throw for empty config object', () => {
-		const config = {} as Partial<DokployDeployConfig>;
-
-		expect(() => validateDokployConfig(config)).toThrow(
-			'Missing Dokploy configuration: endpoint, projectId, applicationId',
-		);
-	});
-
-	it('should include configuration example in error', () => {
-		const config = {} as Partial<DokployDeployConfig>;
-
-		expect(() => validateDokployConfig(config)).toThrow(
-			'Configure in gkm.config.ts:',
-		);
-	});
-});
-
-describe('deployDokploy', () => {
-	beforeEach(() => {
-		server.listen({ onUnhandledRequest: 'bypass' });
-	});
-
-	afterEach(() => {
-		server.resetHandlers();
-		server.close();
-	});
-
-	it('should deploy successfully without master key', async () => {
-		const saveDockerCalls: unknown[] = [];
-
-		server.use(
-			http.post(
-				'https://dokploy.example.com/api/application.saveDockerProvider',
-				async ({ request }) => {
-					const body = await request.json();
-					saveDockerCalls.push(body);
-					return HttpResponse.json({ success: true });
-				},
-			),
-			http.post('https://dokploy.example.com/api/application.deploy', () => {
-				return HttpResponse.json({ success: true });
-			}),
-		);
-
-		const result = await deployDokploy({
-			stage: 'production',
-			tag: 'v1.0.0',
-			imageRef: 'ghcr.io/myorg/app:v1.0.0',
-			config: {
-				endpoint: 'https://dokploy.example.com',
-				projectId: 'proj_123',
-				applicationId: 'app_456',
-			},
-		});
-
-		expect(result.imageRef).toBe('ghcr.io/myorg/app:v1.0.0');
-		expect(result.masterKey).toBeUndefined();
-		expect(result.url).toBe('https://dokploy.example.com/project/proj_123');
-		expect(saveDockerCalls).toHaveLength(1);
-		expect(saveDockerCalls[0]).toMatchObject({
-			applicationId: 'app_456',
-			dockerImage: 'ghcr.io/myorg/app:v1.0.0',
-		});
-	});
-
-	it('should deploy with master key and update environment', async () => {
-		const envCalls: unknown[] = [];
-
-		server.use(
-			http.post(
-				'https://dokploy.example.com/api/application.saveDockerProvider',
-				() => {
-					return HttpResponse.json({ success: true });
-				},
-			),
-			http.post(
-				'https://dokploy.example.com/api/application.saveEnvironment',
-				async ({ request }) => {
-					const body = await request.json();
-					envCalls.push(body);
-					return HttpResponse.json({ success: true });
-				},
-			),
-			http.post('https://dokploy.example.com/api/application.deploy', () => {
-				return HttpResponse.json({ success: true });
-			}),
-		);
-
-		const result = await deployDokploy({
-			stage: 'production',
-			tag: 'v1.0.0',
-			imageRef: 'ghcr.io/myorg/app:v1.0.0',
-			masterKey: 'secret-master-key',
-			config: {
-				endpoint: 'https://dokploy.example.com',
-				projectId: 'proj_123',
-				applicationId: 'app_456',
-			},
-		});
-
-		expect(result.masterKey).toBe('secret-master-key');
-		expect(envCalls).toHaveLength(1);
-		expect(envCalls[0]).toMatchObject({
-			applicationId: 'app_456',
-			env: 'GKM_MASTER_KEY=secret-master-key',
-		});
-	});
-
-	it('should handle API error with message', async () => {
-		server.use(
-			http.post(
-				'https://dokploy.example.com/api/application.saveDockerProvider',
-				() => {
-					return HttpResponse.json({ success: true });
-				},
-			),
-			http.post('https://dokploy.example.com/api/application.deploy', () => {
-				return HttpResponse.json(
-					{ message: 'Application not found' },
-					{ status: 404 },
-				);
-			}),
-		);
-
-		await expect(
-			deployDokploy({
-				stage: 'production',
-				tag: 'v1.0.0',
-				imageRef: 'ghcr.io/myorg/app:v1.0.0',
-				config: {
-					endpoint: 'https://dokploy.example.com',
-					projectId: 'proj_123',
-					applicationId: 'app_456',
-				},
-			}),
-		).rejects.toThrow('Dokploy API error: Application not found');
-	});
-
-	it('should handle API error with issues', async () => {
-		server.use(
-			http.post(
-				'https://dokploy.example.com/api/application.saveDockerProvider',
-				() => {
-					return HttpResponse.json({ success: true });
-				},
-			),
-			http.post('https://dokploy.example.com/api/application.deploy', () => {
-				return HttpResponse.json(
-					{
-						message: 'Validation failed',
-						issues: [{ message: 'Invalid field' }, { message: 'Missing data' }],
-					},
-					{ status: 400 },
-				);
-			}),
-		);
-
-		await expect(
-			deployDokploy({
-				stage: 'production',
-				tag: 'v1.0.0',
-				imageRef: 'ghcr.io/myorg/app:v1.0.0',
-				config: {
-					endpoint: 'https://dokploy.example.com',
-					projectId: 'proj_123',
-					applicationId: 'app_456',
-				},
-			}),
-		).rejects.toThrow('Issues: Invalid field, Missing data');
-	});
-
-	it('should handle API error without JSON body', async () => {
-		server.use(
-			http.post(
-				'https://dokploy.example.com/api/application.saveDockerProvider',
-				() => {
-					return HttpResponse.json({ success: true });
-				},
-			),
-			http.post('https://dokploy.example.com/api/application.deploy', () => {
-				return new HttpResponse('Internal Server Error', { status: 500 });
-			}),
-		);
-
-		await expect(
-			deployDokploy({
-				stage: 'production',
-				tag: 'v1.0.0',
-				imageRef: 'ghcr.io/myorg/app:v1.0.0',
-				config: {
-					endpoint: 'https://dokploy.example.com',
-					projectId: 'proj_123',
-					applicationId: 'app_456',
-				},
-			}),
-		).rejects.toThrow('Dokploy API error: 500');
-	});
-
-	it('should use registryId from config', async () => {
-		const saveDockerCalls: unknown[] = [];
-
-		server.use(
-			http.post(
-				'https://dokploy.example.com/api/application.saveDockerProvider',
-				async ({ request }) => {
-					const body = await request.json();
-					saveDockerCalls.push(body);
-					return HttpResponse.json({ success: true });
-				},
-			),
-			http.post('https://dokploy.example.com/api/application.deploy', () => {
-				return HttpResponse.json({ success: true });
-			}),
-		);
-
-		await deployDokploy({
-			stage: 'production',
-			tag: 'v1.0.0',
-			imageRef: 'ghcr.io/myorg/app:v1.0.0',
-			config: {
-				endpoint: 'https://dokploy.example.com',
-				projectId: 'proj_123',
-				applicationId: 'app_456',
-				registryId: 'reg_789',
-			},
-		});
-
-		expect(saveDockerCalls).toHaveLength(1);
-		expect(saveDockerCalls[0]).toMatchObject({
-			applicationId: 'app_456',
-			dockerImage: 'ghcr.io/myorg/app:v1.0.0',
-			registryId: 'reg_789',
-		});
-	});
-
-	it('should use stored registryId when not in config', async () => {
-		const { getDokployRegistryId } = await import('../../auth');
-		vi.mocked(getDokployRegistryId).mockResolvedValueOnce('stored_reg_123');
-
-		const saveDockerCalls: unknown[] = [];
-
-		server.use(
-			http.post(
-				'https://dokploy.example.com/api/application.saveDockerProvider',
-				async ({ request }) => {
-					const body = await request.json();
-					saveDockerCalls.push(body);
-					return HttpResponse.json({ success: true });
-				},
-			),
-			http.post('https://dokploy.example.com/api/application.deploy', () => {
-				return HttpResponse.json({ success: true });
-			}),
-		);
-
-		await deployDokploy({
-			stage: 'production',
-			tag: 'v1.0.0',
-			imageRef: 'ghcr.io/myorg/app:v1.0.0',
-			config: {
-				endpoint: 'https://dokploy.example.com',
-				projectId: 'proj_123',
-				applicationId: 'app_456',
-			},
-		});
-
-		expect(saveDockerCalls).toHaveLength(1);
-		expect(saveDockerCalls[0]).toMatchObject({
-			applicationId: 'app_456',
-			dockerImage: 'ghcr.io/myorg/app:v1.0.0',
-			registryId: 'stored_reg_123',
-		});
-	});
-
-	it('should use registryCredentials from config', async () => {
-		const saveDockerCalls: unknown[] = [];
-
-		server.use(
-			http.post(
-				'https://dokploy.example.com/api/application.saveDockerProvider',
-				async ({ request }) => {
-					const body = await request.json();
-					saveDockerCalls.push(body);
-					return HttpResponse.json({ success: true });
-				},
-			),
-			http.post('https://dokploy.example.com/api/application.deploy', () => {
-				return HttpResponse.json({ success: true });
-			}),
-		);
-
-		await deployDokploy({
-			stage: 'production',
-			tag: 'v1.0.0',
-			imageRef: 'ghcr.io/myorg/app:v1.0.0',
-			config: {
-				endpoint: 'https://dokploy.example.com',
-				projectId: 'proj_123',
-				applicationId: 'app_456',
-				registryCredentials: {
-					registryUrl: 'ghcr.io',
-					username: 'myuser',
-					password: 'mytoken',
-				},
-			},
-		});
-
-		expect(saveDockerCalls).toHaveLength(1);
-		expect(saveDockerCalls[0]).toMatchObject({
-			applicationId: 'app_456',
-			dockerImage: 'ghcr.io/myorg/app:v1.0.0',
-			username: 'myuser',
-			password: 'mytoken',
-			registryUrl: 'ghcr.io',
-		});
-	});
-});
-
-describe('generateTag', () => {
-	it('should generate tag with stage and timestamp', () => {
-		const tag = generateTag('production');
-
-		expect(tag).toMatch(/^production-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}$/);
-	});
-
-	it('should use stage prefix', () => {
-		const tag = generateTag('staging');
-
-		expect(tag.startsWith('staging-')).toBe(true);
-	});
-
-	it('should generate unique tags', () => {
-		const tag1 = generateTag('dev');
-		const tag2 = generateTag('dev');
-
-		// Tags generated at the same second should be equal
-		// But the format should be consistent
-		expect(tag1).toMatch(/^dev-/);
-		expect(tag2).toMatch(/^dev-/);
-	});
-
-	it('should handle different stage names', () => {
-		expect(generateTag('prod')).toMatch(/^prod-/);
-		expect(generateTag('development')).toMatch(/^development-/);
-		expect(generateTag('test-env')).toMatch(/^test-env-/);
-	});
-});

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

@@ -1,235 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import type { NormalizedAppConfig } from '../../workspace/types';
-import {
-	generatePublicUrlBuildArgs,
-	getPublicUrlArgNames,
-	isMainFrontendApp,
-	resolveHost,
-} from '../domain';
-
-describe('resolveHost', () => {
-	const dokployConfig = {
-		endpoint: 'https://dokploy.example.com',
-		projectId: 'test-project',
-		domains: {
-			development: 'dev.myapp.com',
-			staging: 'staging.myapp.com',
-			production: 'myapp.com',
-		},
-	};
-
-	const createApp = (
-		overrides: Partial<NormalizedAppConfig> = {},
-	): NormalizedAppConfig => ({
-		type: 'backend',
-		path: 'apps/api',
-		port: 3000,
-		dependencies: [],
-		resolvedDeployTarget: 'dokploy',
-		...overrides,
-	});
-
-	it('should return explicit app domain override (string)', () => {
-		const app = createApp({ domain: 'api.custom.com' });
-		const host = resolveHost('api', app, 'production', dokployConfig, false);
-		expect(host).toBe('api.custom.com');
-	});
-
-	it('should return stage-specific domain override', () => {
-		const app = createApp({
-			domain: {
-				production: 'login.myapp.com',
-				staging: 'login.staging.myapp.com',
-			},
-		});
-		const host = resolveHost('auth', app, 'production', dokployConfig, false);
-		expect(host).toBe('login.myapp.com');
-	});
-
-	it('should fallback to base domain pattern when no stage match in override', () => {
-		const app = createApp({
-			domain: { production: 'custom.myapp.com' },
-		});
-		const host = resolveHost('api', app, 'development', dokployConfig, false);
-		expect(host).toBe('api.dev.myapp.com');
-	});
-
-	it('should return base domain for main frontend app', () => {
-		const app = createApp({ type: 'web' });
-		const host = resolveHost('web', app, 'production', dokployConfig, true);
-		expect(host).toBe('myapp.com');
-	});
-
-	it('should return prefixed domain for non-main apps', () => {
-		const app = createApp();
-		const host = resolveHost('api', app, 'production', dokployConfig, false);
-		expect(host).toBe('api.myapp.com');
-	});
-
-	it('should use correct base domain for each stage', () => {
-		const app = createApp();
-
-		expect(resolveHost('api', app, 'development', dokployConfig, false)).toBe(
-			'api.dev.myapp.com',
-		);
-		expect(resolveHost('api', app, 'staging', dokployConfig, false)).toBe(
-			'api.staging.myapp.com',
-		);
-		expect(resolveHost('api', app, 'production', dokployConfig, false)).toBe(
-			'api.myapp.com',
-		);
-	});
-
-	it('should throw error when no domain configured for stage', () => {
-		const app = createApp();
-		expect(() =>
-			resolveHost('api', app, 'unknown-stage', dokployConfig, false),
-		).toThrow('No domain configured for stage "unknown-stage"');
-	});
-
-	it('should throw error when dokployConfig has no domains', () => {
-		const app = createApp();
-		const configWithoutDomains = {
-			endpoint: 'https://dokploy.example.com',
-			projectId: 'test-project',
-		};
-		expect(() =>
-			resolveHost('api', app, 'production', configWithoutDomains, false),
-		).toThrow('No domain configured for stage "production"');
-	});
-});
-
-describe('isMainFrontendApp', () => {
-	const createApp = (type: 'backend' | 'web'): NormalizedAppConfig => ({
-		type,
-		path: 'apps/test',
-		port: 3000,
-		dependencies: [],
-		resolvedDeployTarget: 'dokploy',
-	});
-
-	it('should return false for backend apps', () => {
-		const apps = {
-			api: createApp('backend'),
-			web: createApp('web'),
-		};
-		expect(isMainFrontendApp('api', apps.api, apps)).toBe(false);
-	});
-
-	it('should return true for app named "web" if it is frontend', () => {
-		const apps = {
-			api: createApp('backend'),
-			web: createApp('web'),
-			admin: createApp('web'),
-		};
-		expect(isMainFrontendApp('web', apps.web, apps)).toBe(true);
-	});
-
-	it('should return true for first frontend app when no "web" app', () => {
-		const apps = {
-			api: createApp('backend'),
-			dashboard: createApp('web'),
-			admin: createApp('web'),
-		};
-		expect(isMainFrontendApp('dashboard', apps.dashboard, apps)).toBe(true);
-		expect(isMainFrontendApp('admin', apps.admin, apps)).toBe(false);
-	});
-
-	it('should return false for non-first frontend when no "web" app', () => {
-		const apps = {
-			api: createApp('backend'),
-			dashboard: createApp('web'),
-			admin: createApp('web'),
-		};
-		expect(isMainFrontendApp('admin', apps.admin, apps)).toBe(false);
-	});
-
-	it('should return false when no frontend apps in allApps (edge case)', () => {
-		// Edge case: checking a frontend app against an empty allApps
-		const frontendApp = createApp('web');
-		expect(isMainFrontendApp('myapp', frontendApp, {})).toBe(false);
-	});
-});
-
-describe('generatePublicUrlBuildArgs', () => {
-	const createApp = (dependencies: string[]): NormalizedAppConfig => ({
-		type: 'web',
-		path: 'apps/web',
-		port: 3001,
-		dependencies,
-		resolvedDeployTarget: 'dokploy',
-	});
-
-	it('should generate build args for dependencies', () => {
-		const app = createApp(['api', 'auth']);
-		const deployedUrls = {
-			api: 'https://api.myapp.com',
-			auth: 'https://auth.myapp.com',
-		};
-
-		const buildArgs = generatePublicUrlBuildArgs(app, deployedUrls);
-
-		expect(buildArgs).toEqual([
-			'NEXT_PUBLIC_API_URL=https://api.myapp.com',
-			'NEXT_PUBLIC_AUTH_URL=https://auth.myapp.com',
-		]);
-	});
-
-	it('should skip missing dependencies', () => {
-		const app = createApp(['api', 'auth', 'missing']);
-		const deployedUrls = {
-			api: 'https://api.myapp.com',
-			// auth and missing are not deployed yet
-		};
-
-		const buildArgs = generatePublicUrlBuildArgs(app, deployedUrls);
-
-		expect(buildArgs).toEqual(['NEXT_PUBLIC_API_URL=https://api.myapp.com']);
-	});
-
-	it('should return empty array when no dependencies', () => {
-		const app = createApp([]);
-		const deployedUrls = { api: 'https://api.myapp.com' };
-
-		const buildArgs = generatePublicUrlBuildArgs(app, deployedUrls);
-
-		expect(buildArgs).toEqual([]);
-	});
-
-	it('should handle uppercase conversion correctly', () => {
-		const app = createApp(['my-api', 'auth-service']);
-		const deployedUrls = {
-			'my-api': 'https://my-api.myapp.com',
-			'auth-service': 'https://auth-service.myapp.com',
-		};
-
-		const buildArgs = generatePublicUrlBuildArgs(app, deployedUrls);
-
-		expect(buildArgs).toEqual([
-			'NEXT_PUBLIC_MY-API_URL=https://my-api.myapp.com',
-			'NEXT_PUBLIC_AUTH-SERVICE_URL=https://auth-service.myapp.com',
-		]);
-	});
-});
-
-describe('getPublicUrlArgNames', () => {
-	const createApp = (dependencies: string[]): NormalizedAppConfig => ({
-		type: 'web',
-		path: 'apps/web',
-		port: 3001,
-		dependencies,
-		resolvedDeployTarget: 'dokploy',
-	});
-
-	it('should return arg names for dependencies', () => {
-		const app = createApp(['api', 'auth']);
-		const argNames = getPublicUrlArgNames(app);
-		expect(argNames).toEqual(['NEXT_PUBLIC_API_URL', 'NEXT_PUBLIC_AUTH_URL']);
-	});
-
-	it('should return empty array when no dependencies', () => {
-		const app = createApp([]);
-		const argNames = getPublicUrlArgNames(app);
-		expect(argNames).toEqual([]);
-	});
-});