@geekmidas/cli 0.42.0 → 0.44.0

package/README.md

@@ -1109,6 +1109,227 @@ const logger = createTelescopeLogger(telescope, new ConsoleLogger());
 
 See the [@geekmidas/telescope documentation](../telescope/README.md) for more details.
 
+## Workspace Configuration
+
+For fullstack monorepo projects with multiple apps, use `defineWorkspace` instead of `defineConfig`:
+
+```typescript
+// gkm.config.ts (at workspace root)
+import { defineWorkspace } from '@geekmidas/cli/config';
+
+export default defineWorkspace({
+  name: 'my-project',
+  apps: {
+    api: {
+      type: 'backend',
+      path: 'apps/api',
+      port: 3000,
+      routes: './src/endpoints/**/*.ts',
+      envParser: './src/config/env#envParser',
+      logger: './src/config/logger#logger',
+      telescope: {
+        enabled: true,
+        path: '/__telescope',
+      },
+      openapi: {
+        enabled: true,
+      },
+    },
+    auth: {
+      type: 'backend',
+      path: 'apps/auth',
+      port: 3002,
+      entry: './src/index.ts',  // Entry-based app (no routes)
+      envParser: './src/config/env#envParser',
+      logger: './src/config/logger#logger',
+    },
+    web: {
+      type: 'frontend',
+      framework: 'nextjs',
+      path: 'apps/web',
+      port: 3001,
+      dependencies: ['api', 'auth'],
+      client: {
+        output: './src/api',
+      },
+    },
+  },
+  shared: {
+    packages: ['packages/*'],
+    models: {
+      path: 'packages/models',
+      schema: 'zod',
+    },
+  },
+  services: {
+    db: true,
+    cache: true,
+    mail: true,
+  },
+  deploy: {
+    default: 'dokploy',
+  },
+});
+```
+
+### App Types
+
+#### Routes-Based Backend Apps
+
+Standard API apps using endpoint discovery:
+
+```typescript
+api: {
+  type: 'backend',
+  path: 'apps/api',
+  port: 3000,
+  routes: './src/endpoints/**/*.ts',  // Glob pattern for endpoints
+  envParser: './src/config/env#envParser',
+  logger: './src/config/logger#logger',
+}
+```
+
+These apps use `gkm build --provider server` internally to generate a Hono server from discovered endpoints.
+
+#### Entry-Based Backend Apps
+
+Apps with a custom entry point (like authentication services using better-auth):
+
+```typescript
+auth: {
+  type: 'backend',
+  path: 'apps/auth',
+  port: 3002,
+  entry: './src/index.ts',  // Direct entry point
+  envParser: './src/config/env#envParser',
+  logger: './src/config/logger#logger',
+}
+```
+
+Entry-based apps are bundled directly with esbuild into a standalone file. All dependencies are bundled, producing a single `index.mjs` file that runs without `node_modules`.
+
+Example entry point for an auth service:
+
+```typescript
+// apps/auth/src/index.ts
+import { Hono } from 'hono';
+import { serve } from '@hono/node-server';
+import { auth } from './auth.js';
+
+const app = new Hono();
+
+app.get('/health', (c) => c.json({ status: 'ok' }));
+app.on(['POST', 'GET'], '/api/auth/*', (c) => auth.handler(c.req.raw));
+
+serve({ fetch: app.fetch, port: 3002 });
+```
+
+#### Frontend Apps
+
+Next.js or other frontend frameworks:
+
+```typescript
+web: {
+  type: 'frontend',
+  framework: 'nextjs',
+  path: 'apps/web',
+  port: 3001,
+  dependencies: ['api', 'auth'],  // Apps this depends on
+  client: {
+    output: './src/api',  // Where to generate API client
+  },
+}
+```
+
+### Workspace Docker Generation
+
+When running `gkm docker` in a workspace, the CLI generates optimized Dockerfiles for each app:
+
+```bash
+gkm docker
+```
+
+**Generated files:**
+- `.gkm/docker/Dockerfile.api` - Routes-based backend (uses `gkm build`)
+- `.gkm/docker/Dockerfile.auth` - Entry-based backend (uses esbuild bundling)
+- `.gkm/docker/Dockerfile.web` - Next.js standalone output
+- `.gkm/docker/docker-compose.yml` - Full stack with all apps and services
+- `.dockerignore` - Optimized ignore patterns
+
+**Dockerfile types by app:**
+
+| App Type | Build Method | Output |
+|----------|--------------|--------|
+| `routes` backend | `gkm build --provider server` | `.gkm/server/dist/server.mjs` |
+| `entry` backend | `esbuild --bundle --packages=bundle` | `dist/index.mjs` |
+| `nextjs` frontend | `next build` (standalone) | `.next/standalone` |
+
+**Entry-based bundling:**
+
+Entry-based apps use esbuild with full dependency bundling:
+
+```bash
+npx esbuild ./src/index.ts \
+  --bundle \
+  --platform=node \
+  --target=node22 \
+  --format=esm \
+  --outfile=dist/index.mjs \
+  --packages=bundle \
+  --banner:js='import { createRequire } from "module"; const require = createRequire(import.meta.url);'
+```
+
+The `--packages=bundle` flag bundles all dependencies (unlike tsdown's default behavior). The banner adds CommonJS compatibility for packages that use `require()` internally.
+
+### Workspace Interface
+
+```typescript
+interface WorkspaceConfig {
+  name: string;
+  apps: Record<string, AppConfig>;
+  shared?: {
+    packages?: string[];
+    models?: {
+      path: string;
+      schema: 'zod' | 'valibot';
+    };
+  };
+  services?: {
+    db?: boolean;
+    cache?: boolean;
+    mail?: boolean;
+  };
+  deploy?: {
+    default?: 'dokploy' | 'docker';
+  };
+}
+
+interface BackendAppConfig {
+  type: 'backend';
+  path: string;
+  port: number;
+  routes?: string;           // Glob pattern for routes-based apps
+  entry?: string;            // Entry file for entry-based apps
+  envParser: string;
+  logger: string;
+  telescope?: TelescopeConfig;
+  openapi?: { enabled: boolean };
+}
+
+interface FrontendAppConfig {
+  type: 'frontend';
+  framework: 'nextjs';
+  path: string;
+  port: number;
+  dependencies?: string[];   // Other apps this depends on
+  client?: {
+    output: string;          // Where to generate typed API client
+  };
+}
+
+type AppConfig = BackendAppConfig | FrontendAppConfig;
+```
+
 ## Providers
 
 ### AWS API Gateway v1

package/dist/index.cjs

@@ -29,7 +29,7 @@ const node_module = require_chunk.__toESM(require("node:module"));
 
 //#region package.json
 var name = "@geekmidas/cli";
-var version = "0.41.0";
+var version = "0.44.0";
 var description = "CLI tools for building Lambda handlers, server applications, and generating OpenAPI specs";
 var private$1 = false;
 var type = "module";
@@ -1625,7 +1625,8 @@ async function prepareEntryCredentials(options) {
 	credentials.PORT = String(resolvedPort);
 	const secretsDir = (0, node_path.join)(secretsRoot, ".gkm");
 	await (0, node_fs_promises.mkdir)(secretsDir, { recursive: true });
-	const secretsJsonPath = (0, node_path.join)(secretsDir, "dev-secrets.json");
+	const secretsFileName = appName ? `dev-secrets-${appName}.json` : "dev-secrets.json";
+	const secretsJsonPath = (0, node_path.join)(secretsDir, secretsFileName);
 	await (0, node_fs_promises.writeFile)(secretsJsonPath, JSON.stringify(credentials, null, 2));
 	return {
 		credentials,
@@ -3224,7 +3225,7 @@ CMD ["node", "server.mjs"]
 }
 /**
 * Generate a Dockerfile for apps with a custom entry point.
-* Uses tsdown to bundle the entry point into dist/index.mjs.
+* Uses esbuild to bundle the entry point into dist/index.mjs with all dependencies.
 * This is used for apps that don't use gkm routes (e.g., Better Auth servers).
 * @internal Exported for testing
 */
@@ -3287,17 +3288,22 @@ RUN if [ -n "$GKM_ENCRYPTED_CREDENTIALS" ]; then \
       echo "$GKM_CREDENTIALS_IV" > ${appPath}/.gkm/credentials.iv; \
     fi
 
-# Bundle entry point with tsdown (outputs to dist/index.mjs)
+# Bundle entry point with esbuild (outputs to dist/index.mjs)
+# Creates a fully standalone bundle with all dependencies included
 # Use define to embed credentials if present
 RUN cd ${appPath} && \
     if [ -f .gkm/credentials.enc ]; then \
       CREDS=$(cat .gkm/credentials.enc) && \
       IV=$(cat .gkm/credentials.iv) && \
-      npx tsdown ${entry} --outDir dist --format esm \
-        --define __GKM_ENCRYPTED_CREDENTIALS__="'\\"$CREDS\\"'" \
-        --define __GKM_CREDENTIALS_IV__="'\\"$IV\\"'"; \
+      npx esbuild ${entry} --bundle --platform=node --target=node22 --format=esm \
+        --outfile=dist/index.mjs --packages=bundle \
+        --banner:js='import { createRequire } from "module"; const require = createRequire(import.meta.url);' \
+        --define:__GKM_ENCRYPTED_CREDENTIALS__="'\\"$CREDS\\"'" \
+        --define:__GKM_CREDENTIALS_IV__="'\\"$IV\\"'"; \
     else \
-      npx tsdown ${entry} --outDir dist --format esm; \
+      npx esbuild ${entry} --bundle --platform=node --target=node22 --format=esm \
+        --outfile=dist/index.mjs --packages=bundle \
+        --banner:js='import { createRequire } from "module"; const require = createRequire(import.meta.url);'; \
     fi
 
 # Stage 4: Production
@@ -6244,6 +6250,7 @@ export default defineWorkspace({
       type: 'backend',
       path: 'apps/auth',
       port: 3002,
+      entry: './src/index.ts',
       envParser: './src/config/env#envParser',
       logger: './src/config/logger#logger',
     },
@@ -6557,12 +6564,14 @@ const minimalTemplate = {
 		"@geekmidas/schema": GEEKMIDAS_VERSIONS["@geekmidas/schema"],
 		"@hono/node-server": "~1.14.1",
 		hono: "~4.8.2",
-		pino: "~9.6.0"
+		pino: "~9.6.0",
+		zod: "~4.1.0"
 	},
 	devDependencies: {
 		"@biomejs/biome": "~2.3.0",
 		"@geekmidas/cli": GEEKMIDAS_VERSIONS["@geekmidas/cli"],
 		"@types/node": "~22.0.0",
+		esbuild: "~0.27.0",
 		tsx: "~4.20.0",
 		turbo: "~2.3.0",
 		typescript: "~5.8.2",