@geekmidas/cli 0.39.0 → 0.41.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/cli",
-  "version": "0.39.0",
+  "version": "0.41.0",
   "description": "CLI tools for building Lambda handlers, server applications, and generating OpenAPI specs",
   "private": false,
   "type": "module",
@@ -48,11 +48,11 @@
     "lodash.kebabcase": "^4.1.1",
     "openapi-typescript": "^7.4.2",
     "prompts": "~2.4.2",
-    "@geekmidas/constructs": "~0.6.0",
-    "@geekmidas/envkit": "~0.5.0",
-    "@geekmidas/schema": "~0.1.0",
+    "@geekmidas/logger": "~0.4.0",
+    "@geekmidas/constructs": "~0.7.0",
     "@geekmidas/errors": "~0.1.0",
-    "@geekmidas/logger": "~0.4.0"
+    "@geekmidas/schema": "~0.1.0",
+    "@geekmidas/envkit": "~0.6.0"
   },
   "devDependencies": {
     "@types/lodash.kebabcase": "^4.1.9",

package/src/build/bundler.ts

@@ -1,50 +1,15 @@
-import { execSync, spawnSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { mkdir, rename, writeFile } from 'node:fs/promises';
+import { spawnSync } from 'node:child_process';
+import { mkdir, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import type { Construct } from '@geekmidas/constructs';
 
-const MIN_TSDOWN_VERSION = '0.11.0';
-
 /**
- * Check if tsdown is installed and meets minimum version requirement
+ * Banner to inject into ESM bundle for CJS compatibility.
+ * Creates a `require` function using Node's createRequire for packages
+ * that internally use CommonJS require() for Node builtins.
  */
-function checkTsdownVersion(): void {
-	try {
-		const result = execSync('npx tsdown --version', {
-			encoding: 'utf-8',
-			stdio: ['pipe', 'pipe', 'pipe'],
-		});
-		// Output format: "tsdown/0.12.8 darwin-arm64 node-v22.21.1"
-		const match = result.match(/tsdown\/(\d+\.\d+\.\d+)/);
-		if (match) {
-			const version = match[1]!;
-			const [major, minor] = version.split('.').map(Number) as [number, number];
-			const [minMajor, minMinor] = MIN_TSDOWN_VERSION.split('.').map(
-				Number,
-			) as [number, number];
-
-			if (major < minMajor || (major === minMajor && minor < minMinor)) {
-				throw new Error(
-					`tsdown version ${version} is too old. Please upgrade to ${MIN_TSDOWN_VERSION} or later:\n` +
-						'  npm install -D tsdown@latest\n' +
-						'  # or\n' +
-						'  pnpm add -D tsdown@latest',
-				);
-			}
-		}
-	} catch (error) {
-		if (error instanceof Error && error.message.includes('too old')) {
-			throw error;
-		}
-		throw new Error(
-			'tsdown is required for bundling. Please install it:\n' +
-				'  npm install -D tsdown@latest\n' +
-				'  # or\n' +
-				'  pnpm add -D tsdown@latest',
-		);
-	}
-}
+const ESM_CJS_COMPAT_BANNER =
+	'import { createRequire } from "module"; const require = createRequire(import.meta.url);';
 
 export interface BundleOptions {
 	/** Entry point file (e.g., .gkm/server/server.ts) */
@@ -97,11 +62,13 @@ async function collectRequiredEnvVars(
 }
 
 /**
- * Bundle the server application using tsdown
+ * Bundle the server application using esbuild.
+ * Creates a fully standalone bundle with all dependencies included.
  *
  * @param options - Bundle configuration options
  * @returns Bundle result with output path and optional master key
  */
+
 /** Default env var values for docker compose services */
 const DOCKER_SERVICE_ENV_VARS: Record<string, Record<string, string>> = {
 	postgres: {
@@ -129,27 +96,23 @@ export async function bundleServer(
 		dockerServices,
 	} = options;
 
-	// Check tsdown version first
-	checkTsdownVersion();
-
 	// Ensure output directory exists
 	await mkdir(outputDir, { recursive: true });
 
-	// Build command-line arguments for tsdown
+	const mjsOutput = join(outputDir, 'server.mjs');
+
+	// Build command-line arguments for esbuild
 	const args = [
 		'npx',
-		'tsdown',
+		'esbuild',
 		entryPoint,
-		'--no-config', // Don't use any config file from workspace
-		'--out-dir',
-		outputDir,
-		'--format',
-		'esm',
-		'--platform',
-		'node',
-		'--target',
-		'node22',
-		'--clean',
+		'--bundle',
+		'--platform=node',
+		'--target=node22',
+		'--format=esm',
+		`--outfile=${mjsOutput}`,
+		'--packages=bundle', // Bundle all dependencies for standalone output
+		`--banner:js=${ESM_CJS_COMPAT_BANNER}`, // CJS compatibility for packages like pino
 	];
 
 	if (minify) {
@@ -160,14 +123,11 @@ export async function bundleServer(
 		args.push('--sourcemap');
 	}
 
-	// Add external packages
+	// Add external packages (user-specified)
 	for (const ext of external) {
-		args.push('--external', ext);
+		args.push(`--external:${ext}`);
 	}
 
-	// Always exclude node: builtins
-	args.push('--external', 'node:*');
-
 	// Handle secrets injection if stage is provided
 	let masterKey: string | undefined;
 
@@ -252,21 +212,17 @@ export async function bundleServer(
 		const encrypted = encryptSecrets(embeddable);
 		masterKey = encrypted.masterKey;
 
-		// Add define options for build-time injection using tsdown's --env.* format
+		// Add define options for build-time injection using esbuild's --define:KEY=VALUE format
 		const defines = generateDefineOptions(encrypted);
 		for (const [key, value] of Object.entries(defines)) {
-			args.push(`--env.${key}`, value);
+			args.push(`--define:${key}=${JSON.stringify(value)}`);
 		}
 
 		console.log(`  Secrets encrypted for stage "${stage}"`);
 	}
 
-	const mjsOutput = join(outputDir, 'server.mjs');
-
 	try {
-		// Run tsdown with command-line arguments
-		// Use spawnSync with args array to avoid shell escaping issues with --define values
-		// args is always populated with ['npx', 'tsdown', ...] so cmd is never undefined
+		// Run esbuild with command-line arguments
 		const [cmd, ...cmdArgs] = args as [string, ...string[]];
 		const result = spawnSync(cmd, cmdArgs, {
 			cwd: process.cwd(),
@@ -278,15 +234,7 @@ export async function bundleServer(
 			throw result.error;
 		}
 		if (result.status !== 0) {
-			throw new Error(`tsdown exited with code ${result.status}`);
-		}
-
-		// Rename output to .mjs for explicit ESM
-		// tsdown outputs as server.js for ESM format
-		const jsOutput = join(outputDir, 'server.js');
-
-		if (existsSync(jsOutput)) {
-			await rename(jsOutput, mjsOutput);
+			throw new Error(`esbuild exited with code ${result.status}`);
 		}
 
 		// Add shebang to the bundled file

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

@@ -0,0 +1,231 @@
+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: 'frontend' });
+		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' | 'frontend',
+	): NormalizedAppConfig => ({
+		type,
+		path: 'apps/test',
+		port: 3000,
+		dependencies: [],
+		resolvedDeployTarget: 'dokploy',
+	});
+
+	it('should return false for backend apps', () => {
+		const apps = {
+			api: createApp('backend'),
+			web: createApp('frontend'),
+		};
+		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('frontend'),
+			admin: createApp('frontend'),
+		};
+		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('frontend'),
+			admin: createApp('frontend'),
+		};
+		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('frontend'),
+			admin: createApp('frontend'),
+		};
+		expect(isMainFrontendApp('admin', apps.admin, apps)).toBe(false);
+	});
+});
+
+describe('generatePublicUrlBuildArgs', () => {
+	const createApp = (dependencies: string[]): NormalizedAppConfig => ({
+		type: 'frontend',
+		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: 'frontend',
+		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([]);
+	});
+});