@geekmidas/cli 0.13.0 → 0.15.0

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

@@ -2,11 +2,13 @@ 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 getDokployToken to return a test token
+// Mock auth functions
 vi.mock('../../auth', () => ({
 	getDokployToken: vi.fn().mockResolvedValue('test-api-token'),
+	getDokployRegistryId: vi.fn().mockResolvedValue(null),
 }));
 
 // MSW server for mocking Dokploy API
@@ -112,7 +114,17 @@ describe('deployDokploy', () => {
 	});
 
 	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 });
 			}),
@@ -132,17 +144,28 @@ describe('deployDokploy', () => {
 		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 updateCalls: unknown[] = [];
+		const envCalls: unknown[] = [];
 
 		server.use(
 			http.post(
-				'https://dokploy.example.com/api/application.update',
+				'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();
-					updateCalls.push(body);
+					envCalls.push(body);
 					return HttpResponse.json({ success: true });
 				},
 			),
@@ -164,8 +187,8 @@ describe('deployDokploy', () => {
 		});
 
 		expect(result.masterKey).toBe('secret-master-key');
-		expect(updateCalls).toHaveLength(1);
-		expect(updateCalls[0]).toMatchObject({
+		expect(envCalls).toHaveLength(1);
+		expect(envCalls[0]).toMatchObject({
 			applicationId: 'app_456',
 			env: 'GKM_MASTER_KEY=secret-master-key',
 		});
@@ -173,6 +196,12 @@ describe('deployDokploy', () => {
 
 	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' },
@@ -197,6 +226,12 @@ describe('deployDokploy', () => {
 
 	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(
 					{
@@ -224,6 +259,12 @@ describe('deployDokploy', () => {
 
 	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 });
 			}),
@@ -242,4 +283,153 @@ describe('deployDokploy', () => {
 			}),
 		).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__/index.spec.ts

@@ -0,0 +1,401 @@
+import { HttpResponse, http } from 'msw';
+import { setupServer } from 'msw/node';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { DokployApi } from '../dokploy-api';
+import { generateTag, provisionServices } from '../index';
+
+const BASE_URL = 'https://dokploy.example.com';
+
+// MSW server for mocking Dokploy API calls
+const server = setupServer();
+
+describe('generateTag', () => {
+	it('should generate tag with stage prefix', () => {
+		const tag = generateTag('production');
+		expect(tag).toMatch(/^production-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}$/);
+	});
+
+	it('should generate tag with staging prefix', () => {
+		const tag = generateTag('staging');
+		expect(tag).toMatch(/^staging-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}$/);
+	});
+
+	it('should generate unique tags', () => {
+		const tag1 = generateTag('test');
+		// Small delay to ensure different timestamp
+		const tag2 = generateTag('test');
+		// Tags should start with same prefix but could be same in fast execution
+		expect(tag1).toMatch(/^test-/);
+		expect(tag2).toMatch(/^test-/);
+	});
+
+	it('should replace colons and periods in timestamp', () => {
+		const tag = generateTag('dev');
+		expect(tag).not.toContain(':');
+		expect(tag).not.toContain('.');
+	});
+});
+
+describe('provisionServices', () => {
+	beforeEach(() => {
+		server.listen({ onUnhandledRequest: 'bypass' });
+	});
+
+	afterEach(() => {
+		server.resetHandlers();
+		server.close();
+		vi.restoreAllMocks();
+	});
+
+	it('should return undefined when no services configured', async () => {
+		const api = new DokployApi({ baseUrl: BASE_URL, token: 'test-token' });
+
+		const result = await provisionServices(
+			api,
+			'proj_1',
+			'env_1',
+			'myapp',
+			undefined,
+		);
+
+		expect(result).toBeUndefined();
+	});
+
+	it('should return undefined when no environmentId', async () => {
+		const api = new DokployApi({ baseUrl: BASE_URL, token: 'test-token' });
+
+		const result = await provisionServices(api, 'proj_1', undefined, 'myapp', {
+			postgres: true,
+		});
+
+		expect(result).toBeUndefined();
+	});
+
+	it('should skip postgres when DATABASE_URL already exists', async () => {
+		const api = new DokployApi({ baseUrl: BASE_URL, token: 'test-token' });
+
+		const result = await provisionServices(
+			api,
+			'proj_1',
+			'env_1',
+			'myapp',
+			{ postgres: true },
+			{ DATABASE_URL: 'postgresql://existing:5432/db' },
+		);
+
+		// Should return undefined since nothing new was provisioned
+		expect(result).toBeUndefined();
+	});
+
+	it('should skip redis when REDIS_URL already exists', async () => {
+		const api = new DokployApi({ baseUrl: BASE_URL, token: 'test-token' });
+
+		const result = await provisionServices(
+			api,
+			'proj_1',
+			'env_1',
+			'myapp',
+			{ redis: true },
+			{ REDIS_URL: 'redis://existing:6379' },
+		);
+
+		expect(result).toBeUndefined();
+	});
+
+	it('should provision postgres and return DATABASE_URL', async () => {
+		server.use(
+			http.post(`${BASE_URL}/api/postgres.create`, async ({ request }) => {
+				const body = (await request.json()) as { databasePassword?: string };
+				return HttpResponse.json({
+					postgresId: 'pg_123',
+					name: 'myapp-db',
+					appName: 'myapp-db',
+					databaseName: 'app',
+					databaseUser: 'postgres',
+					databasePassword: body.databasePassword,
+					applicationStatus: 'idle',
+				});
+			}),
+			http.post(`${BASE_URL}/api/postgres.deploy`, () => {
+				return HttpResponse.json({ success: true });
+			}),
+		);
+
+		const api = new DokployApi({ baseUrl: BASE_URL, token: 'test-token' });
+
+		const result = await provisionServices(api, 'proj_1', 'env_1', 'myapp', {
+			postgres: true,
+		});
+
+		expect(result).toBeDefined();
+		expect(result?.DATABASE_URL).toMatch(
+			/^postgresql:\/\/postgres:[a-f0-9]{32}@myapp-db:5432\/app$/,
+		);
+	});
+
+	it('should provision postgres and return individual connection parameters', async () => {
+		server.use(
+			http.post(`${BASE_URL}/api/postgres.create`, async ({ request }) => {
+				const body = (await request.json()) as { databasePassword?: string };
+				return HttpResponse.json({
+					postgresId: 'pg_123',
+					name: 'myapp-db',
+					appName: 'myapp-db',
+					databaseName: 'mydb',
+					databaseUser: 'dbuser',
+					databasePassword: body.databasePassword,
+					applicationStatus: 'idle',
+				});
+			}),
+			http.post(`${BASE_URL}/api/postgres.deploy`, () => {
+				return HttpResponse.json({ success: true });
+			}),
+		);
+
+		const api = new DokployApi({ baseUrl: BASE_URL, token: 'test-token' });
+
+		const result = await provisionServices(api, 'proj_1', 'env_1', 'myapp', {
+			postgres: true,
+		});
+
+		expect(result).toBeDefined();
+		expect(result?.DATABASE_HOST).toBe('myapp-db');
+		expect(result?.DATABASE_PORT).toBe('5432');
+		expect(result?.DATABASE_NAME).toBe('mydb');
+		expect(result?.DATABASE_USER).toBe('dbuser');
+		expect(result?.DATABASE_PASSWORD).toMatch(/^[a-f0-9]{32}$/);
+	});
+
+	it('should provision redis and return REDIS_URL', async () => {
+		server.use(
+			http.post(`${BASE_URL}/api/redis.create`, async ({ request }) => {
+				const body = (await request.json()) as { databasePassword?: string };
+				return HttpResponse.json({
+					redisId: 'redis_123',
+					name: 'myapp-cache',
+					appName: 'myapp-cache',
+					databasePassword: body.databasePassword,
+					applicationStatus: 'idle',
+				});
+			}),
+			http.post(`${BASE_URL}/api/redis.deploy`, () => {
+				return HttpResponse.json({ success: true });
+			}),
+		);
+
+		const api = new DokployApi({ baseUrl: BASE_URL, token: 'test-token' });
+
+		const result = await provisionServices(api, 'proj_1', 'env_1', 'myapp', {
+			redis: true,
+		});
+
+		expect(result).toBeDefined();
+		expect(result?.REDIS_URL).toMatch(
+			/^redis:\/\/:[a-f0-9]{32}@myapp-cache:6379$/,
+		);
+	});
+
+	it('should provision redis and return individual connection parameters', async () => {
+		server.use(
+			http.post(`${BASE_URL}/api/redis.create`, async ({ request }) => {
+				const body = (await request.json()) as { databasePassword?: string };
+				return HttpResponse.json({
+					redisId: 'redis_123',
+					name: 'myapp-cache',
+					appName: 'myapp-cache',
+					databasePassword: body.databasePassword,
+					applicationStatus: 'idle',
+				});
+			}),
+			http.post(`${BASE_URL}/api/redis.deploy`, () => {
+				return HttpResponse.json({ success: true });
+			}),
+		);
+
+		const api = new DokployApi({ baseUrl: BASE_URL, token: 'test-token' });
+
+		const result = await provisionServices(api, 'proj_1', 'env_1', 'myapp', {
+			redis: true,
+		});
+
+		expect(result).toBeDefined();
+		expect(result?.REDIS_HOST).toBe('myapp-cache');
+		expect(result?.REDIS_PORT).toBe('6379');
+		expect(result?.REDIS_PASSWORD).toMatch(/^[a-f0-9]{32}$/);
+	});
+
+	it('should provision both postgres and redis', async () => {
+		server.use(
+			http.post(`${BASE_URL}/api/postgres.create`, async ({ request }) => {
+				const body = (await request.json()) as { databasePassword?: string };
+				return HttpResponse.json({
+					postgresId: 'pg_123',
+					name: 'myapp-db',
+					appName: 'myapp-db',
+					databaseName: 'app',
+					databaseUser: 'postgres',
+					databasePassword: body.databasePassword,
+				});
+			}),
+			http.post(`${BASE_URL}/api/postgres.deploy`, () => {
+				return HttpResponse.json({ success: true });
+			}),
+			http.post(`${BASE_URL}/api/redis.create`, async ({ request }) => {
+				const body = (await request.json()) as { databasePassword?: string };
+				return HttpResponse.json({
+					redisId: 'redis_123',
+					name: 'myapp-cache',
+					appName: 'myapp-cache',
+					databasePassword: body.databasePassword,
+				});
+			}),
+			http.post(`${BASE_URL}/api/redis.deploy`, () => {
+				return HttpResponse.json({ success: true });
+			}),
+		);
+
+		const api = new DokployApi({ baseUrl: BASE_URL, token: 'test-token' });
+
+		const result = await provisionServices(api, 'proj_1', 'env_1', 'myapp', {
+			postgres: true,
+			redis: true,
+		});
+
+		expect(result).toBeDefined();
+		expect(result?.DATABASE_URL).toBeDefined();
+		expect(result?.REDIS_URL).toBeDefined();
+	});
+
+	it('should handle postgres already exists error gracefully', async () => {
+		server.use(
+			http.post(`${BASE_URL}/api/postgres.create`, () => {
+				return HttpResponse.json(
+					{ message: 'Resource already exists' },
+					{ status: 400 },
+				);
+			}),
+		);
+
+		const api = new DokployApi({ baseUrl: BASE_URL, token: 'test-token' });
+
+		// Should not throw, just return undefined for that service
+		const result = await provisionServices(api, 'proj_1', 'env_1', 'myapp', {
+			postgres: true,
+		});
+
+		expect(result).toBeUndefined();
+	});
+
+	it('should handle redis already exists error gracefully', async () => {
+		server.use(
+			http.post(`${BASE_URL}/api/redis.create`, () => {
+				return HttpResponse.json(
+					{ message: 'duplicate key error' },
+					{ status: 400 },
+				);
+			}),
+		);
+
+		const api = new DokployApi({ baseUrl: BASE_URL, token: 'test-token' });
+
+		const result = await provisionServices(api, 'proj_1', 'env_1', 'myapp', {
+			redis: true,
+		});
+
+		expect(result).toBeUndefined();
+	});
+});
+
+describe('DockerComposeServices parsing', () => {
+	it('should parse array format', () => {
+		const composeServices = ['postgres', 'redis'];
+		const dockerServices = {
+			postgres: composeServices.includes('postgres'),
+			redis: composeServices.includes('redis'),
+			rabbitmq: composeServices.includes('rabbitmq'),
+		};
+
+		expect(dockerServices).toEqual({
+			postgres: true,
+			redis: true,
+			rabbitmq: false,
+		});
+	});
+
+	it('should parse object format', () => {
+		const composeServices = { postgres: true, redis: false };
+		const dockerServices = {
+			postgres: Boolean(composeServices.postgres),
+			redis: Boolean(composeServices.redis),
+			rabbitmq: false,
+		};
+
+		expect(dockerServices).toEqual({
+			postgres: true,
+			redis: false,
+			rabbitmq: false,
+		});
+	});
+
+	it('should handle undefined', () => {
+		const composeServices = undefined;
+		const dockerServices = composeServices ? {} : undefined;
+
+		expect(dockerServices).toBeUndefined();
+	});
+});
+
+describe('image reference construction', () => {
+	it('should construct image ref with registry', () => {
+		const registry = 'ghcr.io/myorg';
+		const imageName = 'myapp';
+		const imageTag = 'v1.0.0';
+		const imageRef = registry
+			? `${registry}/${imageName}:${imageTag}`
+			: `${imageName}:${imageTag}`;
+
+		expect(imageRef).toBe('ghcr.io/myorg/myapp:v1.0.0');
+	});
+
+	it('should construct image ref without registry', () => {
+		const registry = undefined;
+		const imageName = 'myapp';
+		const imageTag = 'v1.0.0';
+		const imageRef = registry
+			? `${registry}/${imageName}:${imageTag}`
+			: `${imageName}:${imageTag}`;
+
+		expect(imageRef).toBe('myapp:v1.0.0');
+	});
+
+	it('should handle different registry formats', () => {
+		// Docker Hub
+		expect(`docker.io/myapp:latest`).toBe('docker.io/myapp:latest');
+		// GCR
+		expect(`gcr.io/project/myapp:v1`).toBe('gcr.io/project/myapp:v1');
+		// ECR
+		expect(`123456789.dkr.ecr.us-east-1.amazonaws.com/myapp:latest`).toBe(
+			'123456789.dkr.ecr.us-east-1.amazonaws.com/myapp:latest',
+		);
+	});
+});
+
+describe('generateTag edge cases', () => {
+	it('should handle stage with special characters', () => {
+		const tag = generateTag('prod-us-east');
+		expect(tag).toMatch(/^prod-us-east-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}$/);
+	});
+
+	it('should generate consistent format', () => {
+		const tags = [
+			generateTag('dev'),
+			generateTag('staging'),
+			generateTag('production'),
+		];
+
+		for (const tag of tags) {
+			// Should match ISO 8601 format with dashes instead of colons/periods
+			expect(tag).toMatch(/^[a-z-]+-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}$/);
+		}
+	});
+});