@geekmidas/cli 1.10.35 → 1.10.37

package/src/docker/index.ts

@@ -3,6 +3,7 @@ import { copyFileSync, existsSync, readFileSync, unlinkSync } from 'node:fs';
 import { mkdir, writeFile } from 'node:fs/promises';
 import { basename, join } from 'node:path';
 import { loadConfig, loadWorkspaceConfig } from '../config';
+import { getPublicUrlArgNames } from '../deploy/domain.js';
 import type { NormalizedWorkspace } from '../workspace/types.js';
 import {
 	generateDockerCompose,
@@ -18,7 +19,9 @@ import {
 	generateEntryDockerfile,
 	generateMultiStageDockerfile,
 	generateNextjsDockerfile,
+	generateNodeWebDockerfile,
 	generateSlimDockerfile,
+	generateViteStaticDockerfile,
 	hasTurboConfig,
 	isMonorepo,
 	resolveDockerConfig,
@@ -342,7 +345,7 @@ async function pushDockerImage(
  */
 export interface AppDockerResult {
 	appName: string;
-	type: 'backend' | 'frontend';
+	type: 'backend' | 'web' | 'mobile';
 	dockerfile: string;
 	imageName: string;
 }
@@ -396,6 +399,15 @@ export async function workspaceDockerCommand(
 
 	// Generate Dockerfile for each app
 	for (const [appName, app] of apps) {
+		// Mobile apps deploy via their own toolchain (e.g. EAS Build for Expo)
+		// — no Docker image is produced.
+		if (app.type === 'mobile') {
+			logger.log(
+				`\n   📱 Skipping Docker for ${appName} (mobile app — deploy via framework toolchain)`,
+			);
+			continue;
+		}
+
 		const appPath = app.path;
 		const fullAppPath = join(workspace.root, appPath);
 
@@ -411,16 +423,31 @@ export async function workspaceDockerCommand(
 
 		let dockerfile: string;
 
-		if (app.type === 'frontend') {
-			// Generate Next.js Dockerfile
-			dockerfile = generateNextjsDockerfile({
+		if (app.type === 'web') {
+			const publicUrlArgs = getPublicUrlArgNames(app);
+			const webOpts = {
 				imageName,
 				baseImage: 'node:22-alpine',
 				port: app.port,
 				appPath,
 				turboPackage,
 				packageManager,
-			});
+				publicUrlArgs,
+			};
+
+			switch (app.framework) {
+				case 'vite':
+					dockerfile = generateViteStaticDockerfile(webOpts);
+					break;
+				case 'tanstack-start':
+				case 'remix':
+					dockerfile = generateNodeWebDockerfile(webOpts);
+					break;
+				default:
+					// nextjs (and any unspecified web framework — schema requires
+					// a valid framework, so this is just a default).
+					dockerfile = generateNextjsDockerfile(webOpts);
+			}
 		} else if (app.entry) {
 			// Backend with custom entry point - use tsdown bundling
 			dockerfile = generateEntryDockerfile({
@@ -479,7 +506,8 @@ export async function workspaceDockerCommand(
 	);
 	logger.log('\n📋 Build commands:');
 	for (const result of results) {
-		const icon = result.type === 'backend' ? '⚙️' : '🌐';
+		const icon =
+			result.type === 'backend' ? '⚙️' : result.type === 'mobile' ? '📱' : '🌐';
 		logger.log(
 			`   ${icon} docker build -f .gkm/docker/Dockerfile.${result.appName} -t ${result.imageName} .`,
 		);

package/src/docker/templates.ts

@@ -927,3 +927,141 @@ ENTRYPOINT ["/sbin/tini", "--"]
 CMD ["node", "index.mjs"]
 `;
 }
+
+/**
+ * Generate a Dockerfile for Node-based SSR web frameworks (TanStack Start,
+ * Remix). Builds with turbo, then runs the framework's production start
+ * script via `npm start`.
+ *
+ * Public URL build args are declared so framework bundlers (Vite, Vinxi)
+ * can inline them at build time. Per-framework prefix is the caller's job.
+ * @internal Exported for testing
+ */
+export function generateNodeWebDockerfile(
+	options: FrontendDockerfileOptions,
+): string {
+	const {
+		baseImage,
+		port,
+		appPath,
+		turboPackage,
+		packageManager,
+		publicUrlArgs = [],
+	} = options;
+
+	const pm = getPmConfig(packageManager);
+	const installPm = pm.install ? `RUN ${pm.install}` : '';
+	const turboInstallCmd = getTurboInstallCmd(packageManager);
+	const turboCmd = packageManager === 'pnpm' ? 'pnpm dlx turbo' : 'npx turbo';
+	const startCmd =
+		packageManager === 'pnpm'
+			? 'pnpm start'
+			: `${pm.lockfile.startsWith('package-lock') ? 'npm' : packageManager} start`;
+
+	const argDecls = publicUrlArgs.map((a) => `ARG ${a}=""`).join('\n');
+	const envDecls = publicUrlArgs.map((a) => `ENV ${a}=$${a}`).join('\n');
+
+	return `# syntax=docker/dockerfile:1
+# Node SSR web Dockerfile (TanStack Start / Remix) with turbo prune
+
+FROM ${baseImage} AS pruner
+WORKDIR /app
+${installPm}
+COPY . .
+RUN ${turboCmd} prune ${turboPackage} --docker
+
+FROM ${baseImage} AS deps
+WORKDIR /app
+${installPm}
+COPY --from=pruner /app/out/${pm.lockfile} ./
+COPY --from=pruner /app/out/json/ ./
+RUN --mount=type=cache,id=${pm.cacheId},target=${pm.cacheTarget} \\
+    ${turboInstallCmd}
+
+FROM deps AS builder
+WORKDIR /app
+${argDecls}
+${envDecls}
+COPY --from=pruner /app/out/full/ ./
+COPY --from=pruner /app/tsconfig.* ./
+RUN ${turboCmd} run build --filter=${turboPackage}
+
+FROM ${baseImage} AS runner
+WORKDIR /app
+RUN apk add --no-cache tini
+RUN addgroup --system --gid 1001 nodejs && \\
+    adduser --system --uid 1001 app
+
+# Copy the whole built workspace — frameworks differ on output paths
+COPY --from=builder --chown=app:nodejs /app/ ./
+
+ENV NODE_ENV=production
+ENV PORT=${port}
+ENV HOSTNAME="0.0.0.0"
+
+USER app
+EXPOSE ${port}
+
+ENTRYPOINT ["/sbin/tini", "--"]
+CMD ["sh", "-c", "cd ${appPath} && ${startCmd}"]
+`;
+}
+
+/**
+ * Generate a Dockerfile for Vite SPA apps. Builds the static bundle with
+ * turbo, then serves it via nginx.
+ * @internal Exported for testing
+ */
+export function generateViteStaticDockerfile(
+	options: FrontendDockerfileOptions,
+): string {
+	const {
+		baseImage,
+		port,
+		appPath,
+		turboPackage,
+		packageManager,
+		publicUrlArgs = [],
+	} = options;
+
+	const pm = getPmConfig(packageManager);
+	const installPm = pm.install ? `RUN ${pm.install}` : '';
+	const turboInstallCmd = getTurboInstallCmd(packageManager);
+	const turboCmd = packageManager === 'pnpm' ? 'pnpm dlx turbo' : 'npx turbo';
+
+	const argDecls = publicUrlArgs.map((a) => `ARG ${a}=""`).join('\n');
+	const envDecls = publicUrlArgs.map((a) => `ENV ${a}=$${a}`).join('\n');
+
+	return `# syntax=docker/dockerfile:1
+# Vite SPA Dockerfile — builds static assets, serves via nginx
+
+FROM ${baseImage} AS pruner
+WORKDIR /app
+${installPm}
+COPY . .
+RUN ${turboCmd} prune ${turboPackage} --docker
+
+FROM ${baseImage} AS deps
+WORKDIR /app
+${installPm}
+COPY --from=pruner /app/out/${pm.lockfile} ./
+COPY --from=pruner /app/out/json/ ./
+RUN --mount=type=cache,id=${pm.cacheId},target=${pm.cacheTarget} \\
+    ${turboInstallCmd}
+
+FROM deps AS builder
+WORKDIR /app
+${argDecls}
+${envDecls}
+COPY --from=pruner /app/out/full/ ./
+COPY --from=pruner /app/tsconfig.* ./
+RUN ${turboCmd} run build --filter=${turboPackage}
+
+FROM nginx:alpine AS runner
+COPY --from=builder /app/${appPath}/dist /usr/share/nginx/html
+RUN printf 'server {\\n  listen ${port};\\n  root /usr/share/nginx/html;\\n  index index.html;\\n  location / { try_files $uri $uri/ /index.html; }\\n}\\n' \\
+    > /etc/nginx/conf.d/default.conf
+EXPOSE ${port}
+CMD ["nginx", "-g", "daemon off;"]
+`;
+}

package/src/generators/OpenApiTsGenerator.ts

@@ -1,5 +1,6 @@
 import type { Endpoint } from '@geekmidas/constructs/endpoints';
 import {
+	getRegisteredZodJsonSchemas,
 	getSchemaMetadata,
 	StandardSchemaJsonSchema,
 } from '@geekmidas/schema/conversion';
@@ -313,6 +314,27 @@ export class OpenApiTsGenerator {
 			}
 		}
 
+		// Pull in every schema registered via `.meta({ id })` in zod's global
+		// registry, even when no endpoint references it directly. This makes
+		// derived schemas like `UserSchema.pick(...)` discoverable through the
+		// named parent type without requiring the parent to be wired into an
+		// endpoint.
+		const registrySchemas = await getRegisteredZodJsonSchemas();
+		for (const [rawName, rawSchema] of Object.entries(registrySchemas)) {
+			const defName = this.pascalCase(rawName);
+			if (collectedDefs.has(defName) || generatedNames.has(defName)) {
+				continue;
+			}
+			const {
+				id: _id,
+				$defs: _defs,
+				...rest
+			} = rawSchema as JsonSchema & {
+				id?: string;
+			};
+			collectedDefs.set(defName, rest as JsonSchema);
+		}
+
 		// Generate interfaces for collected $defs (nested schemas with .meta({ id: 'X' }))
 		for (const [defName, defSchema] of collectedDefs) {
 			if (!generatedNames.has(defName)) {

package/src/generators/__tests__/OpenApiTsGenerator.registry.spec.ts

@@ -0,0 +1,77 @@
+import { e } from '@geekmidas/constructs/endpoints';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { z } from 'zod/v4';
+import { OpenApiTsGenerator } from '../OpenApiTsGenerator';
+
+describe('OpenApiTsGenerator — zod global registry', () => {
+	beforeEach(() => {
+		z.globalRegistry.clear();
+	});
+
+	afterEach(() => {
+		z.globalRegistry.clear();
+	});
+
+	it('emits a named interface for a registered schema even when no endpoint references it directly', async () => {
+		const UserSchema = z
+			.object({
+				id: z.string(),
+				email: z.string(),
+				name: z.string(),
+			})
+			.meta({ id: 'User' });
+
+		const UserResponseSchema = UserSchema.pick({
+			id: true,
+			name: true,
+			email: true,
+		});
+
+		const endpoint = e
+			.get('/users/:id')
+			.output(UserResponseSchema)
+			.handle(async () => ({ id: '1', name: 'a', email: 'a@b.c' }));
+
+		const generator = new OpenApiTsGenerator();
+		const content = await generator.generate([endpoint as any]);
+
+		expect(content).toMatch(/export interface User\b/);
+	});
+
+	it('does not duplicate when the same id is also produced by an endpoint', async () => {
+		const UserSchema = z
+			.object({
+				id: z.string(),
+				email: z.string(),
+				name: z.string(),
+			})
+			.meta({ id: 'User' });
+
+		const endpoint = e
+			.get('/users/:id')
+			.output(UserSchema)
+			.handle(async () => ({ id: '1', name: 'a', email: 'a@b.c' }));
+
+		const generator = new OpenApiTsGenerator();
+		const content = await generator.generate([endpoint as any]);
+
+		const occurrences = content.match(/export interface User\b/g) ?? [];
+		expect(occurrences.length).toBe(1);
+	});
+
+	it('emits multiple registered schemas', async () => {
+		z.object({ id: z.string() }).meta({ id: 'Foo' });
+		z.object({ id: z.string() }).meta({ id: 'Bar' });
+
+		const endpoint = e
+			.get('/ping')
+			.output(z.object({ ok: z.boolean() }))
+			.handle(async () => ({ ok: true }));
+
+		const generator = new OpenApiTsGenerator();
+		const content = await generator.generate([endpoint as any]);
+
+		expect(content).toMatch(/export interface Foo\b/);
+		expect(content).toMatch(/export interface Bar\b/);
+	});
+});

package/src/index.ts

@@ -286,13 +286,17 @@ program
 program
 	.command('openapi')
 	.description('Generate OpenAPI specification from endpoints')
-	.action(async () => {
+	.option(
+		'--app <name>',
+		'Workspace mode: generate for a single named backend app',
+	)
+	.action(async (options: { app?: string }) => {
 		try {
 			const globalOptions = program.opts();
 			if (globalOptions.cwd) {
 				process.chdir(globalOptions.cwd);
 			}
-			await openapiCommand({});
+			await openapiCommand({ app: options.app });
 		} catch (error) {
 			console.error(formatError(error));
 			process.exit(1);

package/src/init/__tests__/generators.spec.ts

@@ -2,11 +2,13 @@ import { describe, expect, it } from 'vitest';
 import { generateConfigFiles } from '../generators/config.js';
 import { generateDockerFiles } from '../generators/docker.js';
 import { generateEnvFiles } from '../generators/env.js';
+import { generateExpoAppFiles } from '../generators/mobile-expo.js';
 import { generateModelsPackage } from '../generators/models.js';
 import { generateMonorepoFiles } from '../generators/monorepo.js';
 import { generatePackageJson } from '../generators/package.js';
 import { generateTestFiles } from '../generators/test.js';
 import { generateUiPackageFiles } from '../generators/ui.js';
+import { generateTanStackWebFiles } from '../generators/web-tanstack.js';
 import { apiTemplate } from '../templates/api.js';
 import type { TemplateOptions } from '../templates/index.js';
 import { minimalTemplate } from '../templates/minimal.js';
@@ -431,6 +433,151 @@ describe('generateMonorepoFiles', () => {
 	});
 });
 
+describe('generateTanStackWebFiles', () => {
+	const fullstackOptions: TemplateOptions = {
+		...baseOptions,
+		template: 'fullstack',
+		monorepo: true,
+		apiPath: 'apps/api',
+		frontendFramework: 'tanstack-start',
+	};
+
+	it('returns empty array for non-fullstack template', () => {
+		expect(generateTanStackWebFiles(baseOptions)).toHaveLength(0);
+	});
+
+	it('generates the expected file paths', () => {
+		const files = generateTanStackWebFiles(fullstackOptions);
+		const paths = files.map((f) => f.path);
+		expect(paths).toContain('apps/web/package.json');
+		expect(paths).toContain('apps/web/vite.config.ts');
+		expect(paths).toContain('apps/web/src/router.tsx');
+		expect(paths).toContain('apps/web/src/routes/__root.tsx');
+		expect(paths).toContain('apps/web/src/routes/index.tsx');
+		expect(paths).toContain('apps/web/src/config/client.ts');
+	});
+
+	it('uses VITE_ prefix in client config, not NEXT_PUBLIC_', () => {
+		const files = generateTanStackWebFiles(fullstackOptions);
+		const clientConfig = files.find(
+			(f) => f.path === 'apps/web/src/config/client.ts',
+		);
+		expect(clientConfig).toBeDefined();
+		expect(clientConfig!.content).toContain('VITE_API_URL');
+		expect(clientConfig!.content).toContain('VITE_AUTH_URL');
+		expect(clientConfig!.content).not.toContain('NEXT_PUBLIC_');
+	});
+
+	it('declares tanstack and vite as dependencies', () => {
+		const files = generateTanStackWebFiles(fullstackOptions);
+		const pkg = JSON.parse(
+			files.find((f) => f.path === 'apps/web/package.json')!.content,
+		);
+		expect(pkg.dependencies['@tanstack/react-start']).toBeDefined();
+		expect(pkg.dependencies['@tanstack/react-router']).toBeDefined();
+		expect(pkg.devDependencies.vite).toBeDefined();
+		expect(pkg.dependencies.next).toBeUndefined();
+	});
+});
+
+describe('generateExpoAppFiles', () => {
+	const fullstackOptions: TemplateOptions = {
+		...baseOptions,
+		template: 'fullstack',
+		monorepo: true,
+		apiPath: 'apps/api',
+		frontendFramework: 'expo',
+	};
+
+	it('returns empty array for non-fullstack template', () => {
+		expect(generateExpoAppFiles(baseOptions)).toHaveLength(0);
+	});
+
+	it('generates the expected Expo file paths', () => {
+		const files = generateExpoAppFiles(fullstackOptions);
+		const paths = files.map((f) => f.path);
+		expect(paths).toContain('apps/app/package.json');
+		expect(paths).toContain('apps/app/app.config.ts');
+		expect(paths).toContain('apps/app/eas.json');
+		expect(paths).toContain('apps/app/babel.config.js');
+		expect(paths).toContain('apps/app/metro.config.js');
+		expect(paths).toContain('apps/app/app/_layout.tsx');
+		expect(paths).toContain('apps/app/app/index.tsx');
+		expect(paths).toContain('apps/app/app/login.tsx');
+		expect(paths).toContain('apps/app/lib/auth-client.ts');
+	});
+
+	it('uses EXPO_PUBLIC_ prefix in config.ts', () => {
+		const files = generateExpoAppFiles(fullstackOptions);
+		const configTs = files.find((f) => f.path === 'apps/app/config.ts');
+		expect(configTs).toBeDefined();
+		expect(configTs!.content).toContain('EXPO_PUBLIC_API_URL');
+		expect(configTs!.content).toContain('EXPO_PUBLIC_AUTH_URL');
+		expect(configTs!.content).not.toContain('VITE_');
+		expect(configTs!.content).not.toContain('NEXT_PUBLIC_');
+	});
+
+	it('seeds eas.json with EXPO_PUBLIC_ env vars per profile', () => {
+		const files = generateExpoAppFiles(fullstackOptions);
+		const eas = JSON.parse(
+			files.find((f) => f.path === 'apps/app/eas.json')!.content,
+		);
+		expect(eas.build.dev.env.EXPO_PUBLIC_API_URL).toBeDefined();
+		expect(eas.build.dev.env.EXPO_PUBLIC_AUTH_URL).toBeDefined();
+	});
+
+	it('declares expo + better-auth/expo as dependencies', () => {
+		const files = generateExpoAppFiles(fullstackOptions);
+		const pkg = JSON.parse(
+			files.find((f) => f.path === 'apps/app/package.json')!.content,
+		);
+		expect(pkg.dependencies.expo).toBeDefined();
+		expect(pkg.dependencies['@better-auth/expo']).toBeDefined();
+		expect(pkg.dependencies['expo-router']).toBeDefined();
+		expect(pkg.dependencies.next).toBeUndefined();
+	});
+});
+
+describe('generateMonorepoFiles - frontendFramework wiring', () => {
+	const fullstackBase: TemplateOptions = {
+		...baseOptions,
+		template: 'fullstack',
+		monorepo: true,
+		apiPath: 'apps/api',
+	};
+
+	it('emits framework: nextjs by default', () => {
+		const files = generateMonorepoFiles(
+			{ ...fullstackBase, frontendFramework: 'nextjs' },
+			minimalTemplate,
+		);
+		const cfg = files.find((f) => f.path === 'gkm.config.ts');
+		expect(cfg!.content).toContain("framework: 'nextjs'");
+		expect(cfg!.content).toContain("path: 'apps/web'");
+	});
+
+	it('emits framework: tanstack-start when selected', () => {
+		const files = generateMonorepoFiles(
+			{ ...fullstackBase, frontendFramework: 'tanstack-start' },
+			minimalTemplate,
+		);
+		const cfg = files.find((f) => f.path === 'gkm.config.ts');
+		expect(cfg!.content).toContain("framework: 'tanstack-start'");
+		expect(cfg!.content).toContain("path: 'apps/web'");
+	});
+
+	it('emits framework: expo and apps/app path when selected', () => {
+		const files = generateMonorepoFiles(
+			{ ...fullstackBase, frontendFramework: 'expo' },
+			minimalTemplate,
+		);
+		const cfg = files.find((f) => f.path === 'gkm.config.ts');
+		expect(cfg!.content).toContain("framework: 'expo'");
+		expect(cfg!.content).toContain("path: 'apps/app'");
+		expect(cfg!.content).toContain('port: 8081');
+	});
+});
+
 describe('generateModelsPackage', () => {
 	it('should return empty array for non-monorepo', () => {
 		const files = generateModelsPackage(baseOptions);

package/src/init/__tests__/init.spec.ts

@@ -379,7 +379,7 @@ describe('initCommand', () => {
 			expect(content).toContain("name: 'my-fullstack'");
 			expect(content).toContain("type: 'backend'");
 			expect(content).toContain("path: 'apps/api'");
-			expect(content).toContain("type: 'frontend'");
+			expect(content).toContain("type: 'web'");
 			expect(content).toContain("framework: 'nextjs'");
 			expect(content).toContain("path: 'apps/web'");
 			expect(content).toContain("packages: ['packages/*']");