@geekmidas/cli 0.10.0 → 0.12.0

package/src/docker/__tests__/templates.spec.ts

@@ -0,0 +1,280 @@
+import { existsSync } from 'node:fs';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { GkmConfig } from '../../types';
+import {
+	detectPackageManager,
+	generateDockerEntrypoint,
+	generateDockerignore,
+	generateMultiStageDockerfile,
+	generateSlimDockerfile,
+	resolveDockerConfig,
+} from '../templates';
+
+// Mock fs.existsSync
+vi.mock('node:fs', async () => {
+	const actual = await vi.importActual<typeof import('node:fs')>('node:fs');
+	return {
+		...actual,
+		existsSync: vi.fn(),
+	};
+});
+
+const mockExistsSync = vi.mocked(existsSync);
+
+describe('docker templates', () => {
+	beforeEach(() => {
+		vi.resetAllMocks();
+	});
+
+	describe('detectPackageManager', () => {
+		it('should detect pnpm from lockfile', () => {
+			mockExistsSync.mockImplementation((path) => {
+				return String(path).includes('pnpm-lock.yaml');
+			});
+
+			expect(detectPackageManager('/test/project')).toBe('pnpm');
+		});
+
+		it('should detect npm from lockfile', () => {
+			mockExistsSync.mockImplementation((path) => {
+				return String(path).includes('package-lock.json');
+			});
+
+			expect(detectPackageManager('/test/project')).toBe('npm');
+		});
+
+		it('should detect yarn from lockfile', () => {
+			mockExistsSync.mockImplementation((path) => {
+				return String(path).includes('yarn.lock');
+			});
+
+			expect(detectPackageManager('/test/project')).toBe('yarn');
+		});
+
+		it('should detect bun from lockfile', () => {
+			mockExistsSync.mockImplementation((path) => {
+				return String(path).includes('bun.lockb');
+			});
+
+			expect(detectPackageManager('/test/project')).toBe('bun');
+		});
+
+		it('should default to pnpm when no lockfile found', () => {
+			mockExistsSync.mockReturnValue(false);
+
+			expect(detectPackageManager('/test/project')).toBe('pnpm');
+		});
+
+		it('should prioritize pnpm over npm when both exist', () => {
+			mockExistsSync.mockImplementation((path) => {
+				const pathStr = String(path);
+				return (
+					pathStr.includes('pnpm-lock.yaml') ||
+					pathStr.includes('package-lock.json')
+				);
+			});
+
+			// pnpm should be detected first due to order
+			expect(detectPackageManager('/test/project')).toBe('pnpm');
+		});
+	});
+
+	describe('generateMultiStageDockerfile', () => {
+		const baseOptions = {
+			imageName: 'my-app',
+			baseImage: 'node:22-alpine',
+			port: 3000,
+			healthCheckPath: '/health',
+			prebuilt: false,
+			packageManager: 'pnpm' as const,
+		};
+
+		it('should generate Dockerfile with BuildKit syntax', () => {
+			const dockerfile = generateMultiStageDockerfile(baseOptions);
+
+			expect(dockerfile).toContain('# syntax=docker/dockerfile:1');
+		});
+
+		it('should include three stages: deps, builder, runner', () => {
+			const dockerfile = generateMultiStageDockerfile(baseOptions);
+
+			expect(dockerfile).toContain('FROM node:22-alpine AS deps');
+			expect(dockerfile).toContain('FROM deps AS builder');
+			expect(dockerfile).toContain('FROM node:22-alpine AS runner');
+		});
+
+		it('should use pnpm fetch for better caching', () => {
+			const dockerfile = generateMultiStageDockerfile(baseOptions);
+
+			expect(dockerfile).toContain('pnpm fetch');
+		});
+
+		it('should install tini for signal handling', () => {
+			const dockerfile = generateMultiStageDockerfile(baseOptions);
+
+			expect(dockerfile).toContain('apk add --no-cache tini');
+			expect(dockerfile).toContain('ENTRYPOINT ["/sbin/tini", "--"]');
+		});
+
+		it('should create non-root user', () => {
+			const dockerfile = generateMultiStageDockerfile(baseOptions);
+
+			expect(dockerfile).toContain('addgroup --system --gid 1001 nodejs');
+			expect(dockerfile).toContain('adduser --system --uid 1001 hono');
+			expect(dockerfile).toContain('USER hono');
+		});
+
+		it('should include health check', () => {
+			const dockerfile = generateMultiStageDockerfile(baseOptions);
+
+			expect(dockerfile).toContain('HEALTHCHECK');
+			expect(dockerfile).toContain('/health');
+		});
+
+		it('should expose configured port', () => {
+			const dockerfile = generateMultiStageDockerfile(baseOptions);
+
+			expect(dockerfile).toContain('EXPOSE 3000');
+			expect(dockerfile).toContain('ENV PORT=3000');
+		});
+
+		it('should use npm when specified', () => {
+			const dockerfile = generateMultiStageDockerfile({
+				...baseOptions,
+				packageManager: 'npm',
+			});
+
+			expect(dockerfile).toContain('npm ci');
+			expect(dockerfile).not.toContain('pnpm');
+		});
+
+		it('should use yarn when specified', () => {
+			const dockerfile = generateMultiStageDockerfile({
+				...baseOptions,
+				packageManager: 'yarn',
+			});
+
+			expect(dockerfile).toContain('yarn install --frozen-lockfile');
+			expect(dockerfile).toContain('yarn.lock');
+		});
+
+		it('should generate turbo Dockerfile when turbo option is set', () => {
+			const dockerfile = generateMultiStageDockerfile({
+				...baseOptions,
+				turbo: true,
+				turboPackage: 'api',
+			});
+
+			expect(dockerfile).toContain('turbo');
+			expect(dockerfile).toContain('pruner');
+		});
+	});
+
+	describe('generateSlimDockerfile', () => {
+		const baseOptions = {
+			imageName: 'my-app',
+			baseImage: 'node:22-alpine',
+			port: 3000,
+			healthCheckPath: '/health',
+			prebuilt: true,
+			packageManager: 'pnpm' as const,
+		};
+
+		it('should generate single-stage Dockerfile', () => {
+			const dockerfile = generateSlimDockerfile(baseOptions);
+
+			// Should not have multiple FROM statements
+			const fromMatches = dockerfile.match(/FROM\s+/g);
+			expect(fromMatches?.length).toBe(1);
+		});
+
+		it('should copy pre-built bundle', () => {
+			const dockerfile = generateSlimDockerfile(baseOptions);
+
+			expect(dockerfile).toContain('COPY .gkm/server/dist/server.mjs');
+		});
+
+		it('should install tini', () => {
+			const dockerfile = generateSlimDockerfile(baseOptions);
+
+			expect(dockerfile).toContain('tini');
+		});
+
+		it('should include health check', () => {
+			const dockerfile = generateSlimDockerfile(baseOptions);
+
+			expect(dockerfile).toContain('HEALTHCHECK');
+		});
+	});
+
+	describe('generateDockerignore', () => {
+		it('should include common ignores', () => {
+			const ignore = generateDockerignore();
+
+			expect(ignore).toContain('node_modules');
+			expect(ignore).toContain('.git');
+			expect(ignore).toContain('.env');
+		});
+
+		it('should not ignore .gkm/server/dist for slim builds', () => {
+			const ignore = generateDockerignore();
+
+			expect(ignore).toContain('!.gkm/server/dist');
+		});
+	});
+
+	describe('generateDockerEntrypoint', () => {
+		it('should generate shell entrypoint script', () => {
+			const entrypoint = generateDockerEntrypoint();
+
+			expect(entrypoint).toContain('#!/bin/sh');
+			expect(entrypoint).toContain('exec');
+		});
+
+		it('should set error handling', () => {
+			const entrypoint = generateDockerEntrypoint();
+
+			expect(entrypoint).toContain('set -e');
+		});
+	});
+
+	describe('resolveDockerConfig', () => {
+		it('should use defaults when no config provided', () => {
+			const config: GkmConfig = {};
+			const result = resolveDockerConfig(config);
+
+			// imageName comes from package.json or defaults to 'api'
+			expect(typeof result.imageName).toBe('string');
+			expect(result.baseImage).toBe('node:22-alpine');
+			expect(result.port).toBe(3000);
+		});
+
+		it('should use config values when provided', () => {
+			const config: GkmConfig = {
+				docker: {
+					imageName: 'my-custom-app',
+					baseImage: 'node:20-alpine',
+					port: 8080,
+				},
+			};
+			const result = resolveDockerConfig(config);
+
+			expect(result.imageName).toBe('my-custom-app');
+			expect(result.baseImage).toBe('node:20-alpine');
+			expect(result.port).toBe(8080);
+		});
+
+		it('should merge partial config with defaults', () => {
+			const config: GkmConfig = {
+				docker: {
+					imageName: 'partial-app',
+				},
+			};
+			const result = resolveDockerConfig(config);
+
+			expect(result.imageName).toBe('partial-app');
+			expect(result.baseImage).toBe('node:22-alpine'); // default
+			expect(result.port).toBe(3000); // default
+		});
+	});
+});

package/src/docker/compose.ts

@@ -0,0 +1,273 @@
+import type {
+	ComposeServiceName,
+	ComposeServicesConfig,
+	ServiceConfig,
+} from '../types';
+
+/** Default Docker images for services */
+export const DEFAULT_SERVICE_IMAGES: Record<ComposeServiceName, string> = {
+	postgres: 'postgres',
+	redis: 'redis',
+	rabbitmq: 'rabbitmq',
+};
+
+/** Default Docker image versions for services */
+export const DEFAULT_SERVICE_VERSIONS: Record<ComposeServiceName, string> = {
+	postgres: '16-alpine',
+	redis: '7-alpine',
+	rabbitmq: '3-management-alpine',
+};
+
+export interface ComposeOptions {
+	imageName: string;
+	registry: string;
+	port: number;
+	healthCheckPath: string;
+	/** Services config - object format or legacy array format */
+	services: ComposeServicesConfig | ComposeServiceName[];
+}
+
+/** Get the default full image reference for a service */
+function getDefaultImage(serviceName: ComposeServiceName): string {
+	return `${DEFAULT_SERVICE_IMAGES[serviceName]}:${DEFAULT_SERVICE_VERSIONS[serviceName]}`;
+}
+
+/** Normalize services config to a consistent format - returns Map of service name to full image reference */
+function normalizeServices(
+	services: ComposeServicesConfig | ComposeServiceName[],
+): Map<ComposeServiceName, string> {
+	const result = new Map<ComposeServiceName, string>();
+
+	if (Array.isArray(services)) {
+		// Legacy array format - use default images
+		for (const name of services) {
+			result.set(name, getDefaultImage(name));
+		}
+	} else {
+		// Object format
+		for (const [name, config] of Object.entries(services)) {
+			const serviceName = name as ComposeServiceName;
+			if (config === true) {
+				// boolean true - use default image
+				result.set(serviceName, getDefaultImage(serviceName));
+			} else if (config && typeof config === 'object') {
+				const serviceConfig = config as ServiceConfig;
+				if (serviceConfig.image) {
+					// Full image reference provided
+					result.set(serviceName, serviceConfig.image);
+				} else {
+					// Version only - use default image name with custom version
+					const version =
+						serviceConfig.version ?? DEFAULT_SERVICE_VERSIONS[serviceName];
+					result.set(
+						serviceName,
+						`${DEFAULT_SERVICE_IMAGES[serviceName]}:${version}`,
+					);
+				}
+			}
+			// false or undefined - skip
+		}
+	}
+
+	return result;
+}
+
+/**
+ * Generate docker-compose.yml for production deployment
+ */
+export function generateDockerCompose(options: ComposeOptions): string {
+	const { imageName, registry, port, healthCheckPath, services } = options;
+
+	// Normalize services to Map<name, version>
+	const serviceMap = normalizeServices(services);
+
+	const imageRef = registry ? `\${REGISTRY:-${registry}}/` : '';
+
+	let yaml = `version: '3.8'
+
+services:
+  api:
+    build:
+      context: ../..
+      dockerfile: .gkm/docker/Dockerfile
+    image: ${imageRef}\${IMAGE_NAME:-${imageName}}:\${TAG:-latest}
+    container_name: ${imageName}
+    restart: unless-stopped
+    ports:
+      - "\${PORT:-${port}}:${port}"
+    environment:
+      - NODE_ENV=production
+`;
+
+	// Add environment variables based on services
+	if (serviceMap.has('postgres')) {
+		yaml += `      - DATABASE_URL=\${DATABASE_URL:-postgresql://postgres:postgres@postgres:5432/app}
+`;
+	}
+
+	if (serviceMap.has('redis')) {
+		yaml += `      - REDIS_URL=\${REDIS_URL:-redis://redis:6379}
+`;
+	}
+
+	if (serviceMap.has('rabbitmq')) {
+		yaml += `      - RABBITMQ_URL=\${RABBITMQ_URL:-amqp://rabbitmq:5672}
+`;
+	}
+
+	yaml += `    healthcheck:
+      test: ["CMD", "wget", "-q", "--spider", "http://localhost:${port}${healthCheckPath}"]
+      interval: 30s
+      timeout: 3s
+      retries: 3
+`;
+
+	// Add depends_on if there are services
+	if (serviceMap.size > 0) {
+		yaml += `    depends_on:
+`;
+		for (const serviceName of serviceMap.keys()) {
+			yaml += `      ${serviceName}:
+        condition: service_healthy
+`;
+		}
+	}
+
+	yaml += `    networks:
+      - app-network
+`;
+
+	// Add service definitions with images
+	const postgresImage = serviceMap.get('postgres');
+	if (postgresImage) {
+		yaml += `
+  postgres:
+    image: ${postgresImage}
+    container_name: postgres
+    restart: unless-stopped
+    environment:
+      POSTGRES_USER: \${POSTGRES_USER:-postgres}
+      POSTGRES_PASSWORD: \${POSTGRES_PASSWORD:-postgres}
+      POSTGRES_DB: \${POSTGRES_DB:-app}
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres"]
+      interval: 5s
+      timeout: 5s
+      retries: 5
+    networks:
+      - app-network
+`;
+	}
+
+	const redisImage = serviceMap.get('redis');
+	if (redisImage) {
+		yaml += `
+  redis:
+    image: ${redisImage}
+    container_name: redis
+    restart: unless-stopped
+    volumes:
+      - redis_data:/data
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 5s
+      timeout: 5s
+      retries: 5
+    networks:
+      - app-network
+`;
+	}
+
+	const rabbitmqImage = serviceMap.get('rabbitmq');
+	if (rabbitmqImage) {
+		yaml += `
+  rabbitmq:
+    image: ${rabbitmqImage}
+    container_name: rabbitmq
+    restart: unless-stopped
+    environment:
+      RABBITMQ_DEFAULT_USER: \${RABBITMQ_USER:-guest}
+      RABBITMQ_DEFAULT_PASS: \${RABBITMQ_PASSWORD:-guest}
+    ports:
+      - "15672:15672"  # Management UI
+    volumes:
+      - rabbitmq_data:/var/lib/rabbitmq
+    healthcheck:
+      test: ["CMD", "rabbitmq-diagnostics", "-q", "ping"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+    networks:
+      - app-network
+`;
+	}
+
+	// Add volumes
+	yaml += `
+volumes:
+`;
+
+	if (serviceMap.has('postgres')) {
+		yaml += `  postgres_data:
+`;
+	}
+
+	if (serviceMap.has('redis')) {
+		yaml += `  redis_data:
+`;
+	}
+
+	if (serviceMap.has('rabbitmq')) {
+		yaml += `  rabbitmq_data:
+`;
+	}
+
+	// Add networks
+	yaml += `
+networks:
+  app-network:
+    driver: bridge
+`;
+
+	return yaml;
+}
+
+/**
+ * Generate a minimal docker-compose.yml for API only
+ */
+export function generateMinimalDockerCompose(
+	options: Omit<ComposeOptions, 'services'>,
+): string {
+	const { imageName, registry, port, healthCheckPath } = options;
+
+	const imageRef = registry ? `\${REGISTRY:-${registry}}/` : '';
+
+	return `version: '3.8'
+
+services:
+  api:
+    build:
+      context: ../..
+      dockerfile: .gkm/docker/Dockerfile
+    image: ${imageRef}\${IMAGE_NAME:-${imageName}}:\${TAG:-latest}
+    container_name: ${imageName}
+    restart: unless-stopped
+    ports:
+      - "\${PORT:-${port}}:${port}"
+    environment:
+      - NODE_ENV=production
+    healthcheck:
+      test: ["CMD", "wget", "-q", "--spider", "http://localhost:${port}${healthCheckPath}"]
+      interval: 30s
+      timeout: 3s
+      retries: 3
+    networks:
+      - app-network
+
+networks:
+  app-network:
+    driver: bridge
+`;
+}