@geekmidas/cli 1.10.41 → 1.12.0

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

@@ -0,0 +1,141 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { type Queue, QueueBuilder } from '@geekmidas/constructs/queue';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { z } from 'zod';
+import {
+	cleanupDir,
+	createMockBuildContext,
+	createTempDir,
+} from '../../__tests__/test-helpers';
+import type { GeneratedConstruct } from '../Generator';
+import { QueueGenerator } from '../QueueGenerator';
+
+const schema = z.object({ orderId: z.string() });
+
+describe('QueueGenerator', () => {
+	let tempDir: string;
+	let outputDir: string;
+	let generator: QueueGenerator;
+	let context: ReturnType<typeof createMockBuildContext>;
+
+	beforeEach(async () => {
+		tempDir = await createTempDir();
+		outputDir = join(tempDir, 'output');
+		generator = new QueueGenerator();
+		context = createMockBuildContext();
+	});
+
+	afterEach(async () => {
+		await cleanupDir(tempDir);
+	});
+
+	const createQueueConstruct = (
+		key: string,
+		name: string,
+	): GeneratedConstruct<Queue<any, any, any, any>> => {
+		const queue = new QueueBuilder()
+			.queue(name)
+			.batchSize(5)
+			.message(schema)
+			.handle(async () => {});
+
+		return {
+			key,
+			name: key.toLowerCase(),
+			construct: queue,
+			path: {
+				absolute: join(tempDir, `${key}.ts`),
+				relative: `${key}.ts`,
+			},
+		};
+	};
+
+	describe('isConstruct', () => {
+		it('identifies queues and rejects everything else', () => {
+			const queue = new QueueBuilder()
+				.queue('orders')
+				.message(schema)
+				.handle(async () => {});
+
+			expect(generator.isConstruct(queue)).toBe(true);
+			expect(generator.isConstruct({})).toBe(false);
+			expect(generator.isConstruct(null)).toBe(false);
+		});
+	});
+
+	describe('aws-lambda provider', () => {
+		it('generates one AWSLambdaQueue handler per queue', async () => {
+			const constructs = [
+				createQueueConstruct('ordersQueue', 'orders'),
+				createQueueConstruct('emailsQueue', 'emails'),
+			];
+
+			const infos = await generator.build(context, constructs, outputDir, {
+				provider: 'aws-lambda',
+			});
+
+			expect(infos).toHaveLength(2);
+			expect(infos[0]).toMatchObject({
+				name: 'orders',
+				handler: expect.stringContaining('queues/ordersQueue.handler'),
+				batchSize: 5,
+			});
+			// Env requirement from the (sniffed) producer flows nowhere here, but the
+			// consumer queue's own services would; assert the field exists.
+			expect(infos[0].environment).toBeDefined();
+
+			const handler = await readFile(
+				join(outputDir, 'queues', 'ordersQueue.ts'),
+				'utf-8',
+			);
+			expect(handler).toContain(
+				"import { AWSLambdaQueue } from '@geekmidas/constructs/aws'",
+			);
+			expect(handler).toContain('import { ordersQueue }');
+			expect(handler).toContain('new AWSLambdaQueue(envParser, ordersQueue)');
+			expect(handler).toContain('export const handler = adapter.handler');
+		});
+
+		it('returns an empty array for no queues', async () => {
+			const infos = await generator.build(context, [], outputDir, {
+				provider: 'aws-lambda',
+			});
+			expect(infos).toEqual([]);
+		});
+	});
+
+	describe('server provider', () => {
+		it('generates queues.ts with the setupQueues poller even when empty', async () => {
+			const infos = await generator.build(context, [], outputDir, {
+				provider: 'server',
+			});
+
+			expect(infos).toEqual([]);
+
+			const content = await readFile(join(outputDir, 'queues.ts'), 'utf-8');
+			expect(content).toContain('export async function setupQueues');
+			expect(content).toContain('const queues = [');
+			expect(content).toContain('EVENT_SUBSCRIBER_CONNECTION_STRING');
+		});
+
+		it('subscribes each queue by its name and validates the payload', async () => {
+			const constructs = [
+				createQueueConstruct('ordersQueue', 'orders'),
+				createQueueConstruct('emailsQueue', 'emails'),
+			];
+
+			await generator.build(context, constructs, outputDir, {
+				provider: 'server',
+			});
+
+			const content = await readFile(join(outputDir, 'queues.ts'), 'utf-8');
+			expect(content).toContain('import { ordersQueue }');
+			expect(content).toContain('import { emailsQueue }');
+			// A queue subscribes to a single "type" — its own name.
+			expect(content).toContain('eventSubscriber.subscribe([queue.name]');
+			expect(content).toContain("queue.messageSchema['~standard'].validate");
+			expect(content).toContain('messages: [validation.value]');
+		});
+	});
+});

package/src/generators/index.ts

@@ -6,4 +6,6 @@ export {
 	type GeneratedConstruct,
 	type GeneratorOptions,
 } from './Generator';
+export { QueueGenerator } from './QueueGenerator';
 export { SubscriberGenerator } from './SubscriberGenerator';
+export { TopicGenerator } from './TopicGenerator';

package/src/index.ts

@@ -236,6 +236,10 @@ program
 	.option('--watch', 'Enable watch mode')
 	.option('--coverage', 'Generate coverage report')
 	.option('--ui', 'Open Vitest UI')
+	.option(
+		'--auto-setup',
+		'Generate a fresh stage (secrets + key) from the workspace config when none exists (for CI; also via GKM_AUTO_SETUP)',
+	)
 	.argument('[pattern]', 'Pattern to filter tests')
 	.action(async (pattern: string | undefined, options: TestOptions) => {
 		try {

package/src/init/versions.ts

@@ -30,22 +30,22 @@ export const GEEKMIDAS_VERSIONS = {
 	'@geekmidas/audit': '~2.0.1',
 	'@geekmidas/auth': '~2.0.1',
 	'@geekmidas/cache': '~1.1.1',
-	'@geekmidas/client': '~5.0.0',
+	'@geekmidas/client': '~6.0.0',
 	'@geekmidas/cloud': '~1.0.1',
-	'@geekmidas/constructs': '~3.1.0',
+	'@geekmidas/constructs': '~4.0.1',
 	'@geekmidas/db': '~1.0.2',
 	'@geekmidas/emailkit': '~1.0.1',
 	'@geekmidas/envkit': '~1.0.7',
 	'@geekmidas/errors': '~1.0.1',
 	'@geekmidas/events': '~1.1.4',
 	'@geekmidas/logger': '~1.0.2',
-	'@geekmidas/rate-limit': '~2.0.1',
-	'@geekmidas/schema': '~1.0.2',
-	'@geekmidas/services': '~1.0.4',
+	'@geekmidas/rate-limit': '~3.0.0',
+	'@geekmidas/schema': '~1.0.3',
+	'@geekmidas/services': '~1.1.1',
 	'@geekmidas/storage': '~2.0.3',
 	'@geekmidas/studio': '~1.0.1',
 	'@geekmidas/telescope': '~1.0.1',
-	'@geekmidas/testkit': '~1.0.9',
+	'@geekmidas/testkit': '~2.0.0',
 	'@geekmidas/cli': CLI_VERSION,
 } as const;
 

package/src/setup/__tests__/auto-setup.spec.ts

@@ -0,0 +1,147 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { rm } from 'node:fs/promises';
+import { homedir, tmpdir } from 'node:os';
+import { basename, join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { readStageSecrets, secretsExist } from '../../secrets/storage.js';
+import type { NormalizedWorkspace } from '../../workspace/types.js';
+import { createFreshWorkspaceSecrets, ensureStageSecrets } from '../index.js';
+
+function createWorkspace(
+	overrides: Partial<NormalizedWorkspace> = {},
+): NormalizedWorkspace {
+	return {
+		name: 'test-project',
+		root: '/tmp/test-project',
+		apps: {
+			api: {
+				type: 'backend',
+				port: 3000,
+				root: '/tmp/test-project/apps/api',
+				packageName: '@test/api',
+				routes: './src/endpoints/**/*.ts',
+				dependencies: [],
+			},
+		},
+		services: { db: true },
+		deploy: {},
+		shared: {},
+		secrets: {},
+		...overrides,
+	} as NormalizedWorkspace;
+}
+
+describe('createFreshWorkspaceSecrets', () => {
+	it('generates postgres credentials when db service is enabled', () => {
+		const secrets = createFreshWorkspaceSecrets(
+			'development',
+			createWorkspace(),
+		);
+
+		expect(secrets.stage).toBe('development');
+		expect(secrets.services.postgres).toBeDefined();
+		expect(secrets.services.postgres?.password).toBeTruthy();
+		expect(secrets.urls.DATABASE_URL).toContain('postgresql://');
+	});
+
+	it('generates a randomized password each call', () => {
+		const a = createFreshWorkspaceSecrets('development', createWorkspace());
+		const b = createFreshWorkspaceSecrets('development', createWorkspace());
+
+		expect(a.services.postgres?.password).not.toBe(
+			b.services.postgres?.password,
+		);
+	});
+
+	it('adds single-app custom secrets', () => {
+		const secrets = createFreshWorkspaceSecrets(
+			'development',
+			createWorkspace(),
+		);
+
+		expect(secrets.custom.NODE_ENV).toBe('development');
+		expect(secrets.custom.JWT_SECRET).toBeTruthy();
+	});
+});
+
+describe('ensureStageSecrets', () => {
+	let testDir: string;
+	const originalGkmConfigPath = process.env.GKM_CONFIG_PATH;
+
+	beforeEach(() => {
+		testDir = join(
+			tmpdir(),
+			`gkm-auto-setup-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+		);
+		mkdirSync(testDir, { recursive: true });
+
+		// Minimal single-app workspace config with a db service.
+		writeFileSync(
+			join(testDir, 'gkm.config.ts'),
+			`import { defineWorkspace } from '@geekmidas/cli/config';
+
+export default defineWorkspace({
+  name: 'test-workspace',
+  apps: {
+    api: {
+      type: 'backend',
+      path: 'apps/api',
+      port: 3001,
+      routes: './src/endpoints/**/*.ts',
+      envParser: './src/config/env#envParser',
+      logger: './src/config/logger#logger',
+    },
+  },
+  services: { db: true },
+});
+`,
+		);
+		const apiDir = join(testDir, 'apps', 'api');
+		mkdirSync(apiDir, { recursive: true });
+		writeFileSync(
+			join(apiDir, 'package.json'),
+			JSON.stringify({ name: '@test/api', version: '0.0.1' }),
+		);
+
+		process.env.GKM_CONFIG_PATH = join(testDir, 'gkm.config.ts');
+	});
+
+	afterEach(async () => {
+		if (originalGkmConfigPath === undefined) {
+			delete process.env.GKM_CONFIG_PATH;
+		} else {
+			process.env.GKM_CONFIG_PATH = originalGkmConfigPath;
+		}
+
+		await rm(testDir, { recursive: true, force: true });
+		// writeStageSecrets mints a key at ~/.gkm/{basename(root)}
+		await rm(join(homedir(), '.gkm', basename(testDir)), {
+			recursive: true,
+			force: true,
+		});
+	});
+
+	it('generates a decryptable stage when none exists', async () => {
+		expect(secretsExist('development', testDir)).toBe(false);
+
+		const generated = await ensureStageSecrets('development', testDir);
+
+		expect(generated).toBe(true);
+		expect(secretsExist('development', testDir)).toBe(true);
+
+		// Round-trips through the keystore the same way `gkm test` reads it.
+		const read = await readStageSecrets('development', testDir);
+		expect(read?.services.postgres).toBeDefined();
+	});
+
+	it('is a no-op when secrets already exist', async () => {
+		await ensureStageSecrets('development', testDir);
+		const before = await readStageSecrets('development', testDir);
+
+		const generated = await ensureStageSecrets('development', testDir);
+
+		expect(generated).toBe(false);
+		const after = await readStageSecrets('development', testDir);
+		expect(after).toEqual(before);
+	});
+});

package/src/setup/index.ts

@@ -288,13 +288,16 @@ export function reconcileSecrets(
 }
 
 /**
- * Generate fresh secrets for the workspace.
+ * Build a fresh StageSecrets object for a workspace: service credentials,
+ * connection URLs, and custom secrets. Pure — does not write to disk or touch
+ * SSM. Service passwords are freshly randomized, so the result must be the same
+ * one used to start the matching Docker containers.
+ * @internal Exported for reuse by `gkm test` auto-setup.
  */
-async function generateFreshSecrets(
+export function createFreshWorkspaceSecrets(
 	stage: string,
 	workspace: NormalizedWorkspace,
-	options: SetupOptions,
-) {
+): StageSecrets {
 	// Determine services from workspace config
 	const serviceNames: ComposeServiceName[] = [];
 	if (workspace.services.db) serviceNames.push('postgres');
@@ -313,8 +316,7 @@ async function generateFreshSecrets(
 	// Generate fullstack-aware custom secrets
 	const isMultiApp = Object.keys(workspace.apps).length > 1;
 	if (isMultiApp) {
-		const customSecrets = generateFullstackCustomSecrets(workspace);
-		secrets.custom = customSecrets;
+		secrets.custom = generateFullstackCustomSecrets(workspace);
 	} else {
 		secrets.custom = {
 			NODE_ENV: 'development',
@@ -324,6 +326,44 @@ async function generateFreshSecrets(
 		};
 	}
 
+	return secrets;
+}
+
+/**
+ * Ensure a usable secret set exists for a stage, generating a fresh one from the
+ * workspace config when none is present. No-op if secrets already exist.
+ *
+ * Powers `gkm test --auto-setup` / `GKM_AUTO_SETUP`: CI can run without a
+ * committed secrets file or a shared encryption key — the stage is regenerated
+ * from the committed `gkm.config.ts`, and `writeStageSecrets` mints a local key.
+ *
+ * @returns true if fresh secrets were generated, false if existing ones were kept
+ */
+export async function ensureStageSecrets(
+	stage: string,
+	cwd: string = process.cwd(),
+): Promise<boolean> {
+	const { workspace } = await loadWorkspaceConfig(cwd);
+
+	if (secretsExist(stage, workspace.root)) {
+		return false;
+	}
+
+	const secrets = createFreshWorkspaceSecrets(stage, workspace);
+	await writeStageSecrets(secrets, workspace.root);
+	return true;
+}
+
+/**
+ * Generate fresh secrets for the workspace.
+ */
+async function generateFreshSecrets(
+	stage: string,
+	workspace: NormalizedWorkspace,
+	options: SetupOptions,
+) {
+	const secrets = createFreshWorkspaceSecrets(stage, workspace);
+
 	// Write secrets
 	await writeStageSecrets(secrets, workspace.root);
 	logger.log(`   Secrets written to .gkm/secrets/${stage}.json`);

package/src/test/index.ts

@@ -21,6 +21,12 @@ export interface TestOptions {
 	ui?: boolean;
 	/** Pattern to filter tests */
 	pattern?: string;
+	/**
+	 * Generate a fresh stage (secrets + encryption key) from the workspace config
+	 * when none exists, instead of requiring committed secrets / a shared key.
+	 * Intended for CI. Also enabled by the GKM_AUTO_SETUP env var.
+	 */
+	autoSetup?: boolean;
 }
 
 /**
@@ -33,6 +39,17 @@ export async function testCommand(options: TestOptions = {}): Promise<void> {
 
 	console.log(`\n🧪 Running tests with ${stage} environment...\n`);
 
+	// 0. Auto-setup (CI): regenerate a fresh stage from the workspace config when
+	//    none exists, so tests run without committed secrets or a shared key.
+	const autoSetup = options.autoSetup || Boolean(process.env.GKM_AUTO_SETUP);
+	if (autoSetup) {
+		const { ensureStageSecrets } = await import('../setup/index.js');
+		const generated = await ensureStageSecrets(stage, cwd);
+		if (generated) {
+			console.log(`  🔐 Generated fresh ${stage} secrets (auto-setup)`);
+		}
+	}
+
 	// 1. Load .env files
 	const defaultEnv = loadEnvFiles('.env');
 	if (defaultEnv.loaded.length > 0) {

package/src/types.ts

@@ -239,6 +239,8 @@ export interface GkmConfig {
 	functions?: Routes;
 	crons?: Routes;
 	subscribers?: Routes;
+	queues?: Routes;
+	topics?: Routes;
 	envParser: string;
 	logger: string;
 	providers?: ProvidersConfig;
@@ -347,54 +349,15 @@ export interface BuildResult {
 	masterKey?: string;
 }
 
-export interface RouteInfo {
-	path: string;
-	method: string;
-	handler: string;
-	timeout?: number;
-	memorySize?: number;
-	environment?: string[];
-	authorizer: string;
-}
-
-export interface FunctionInfo {
-	name: string;
-	handler: string;
-	timeout?: number;
-	memorySize?: number;
-	environment?: string[];
-}
-
-export interface CronInfo {
-	name: string;
-	handler: string;
-	schedule: string;
-	timeout?: number;
-	memorySize?: number;
-	environment?: string[];
-}
-
-export interface SubscriberInfo {
-	name: string;
-	handler: string;
-	subscribedEvents: string[];
-	timeout?: number;
-	memorySize?: number;
-	environment?: string[];
-}
-
-export interface RoutesManifest {
-	routes: RouteInfo[];
-}
-
-export interface FunctionsManifest {
-	functions: FunctionInfo[];
-}
-
-export interface CronsManifest {
-	crons: CronInfo[];
-}
-
-export interface SubscribersManifest {
-	subscribers: SubscriberInfo[];
-}
+// The deployment manifest types are a shared, dependency-free data contract
+// in `@geekmidas/manifest`, re-exported here for back-compat with existing
+// `@geekmidas/cli` imports.
+export type {
+	CronInfo,
+	FunctionInfo,
+	Manifest,
+	QueueInfo,
+	RouteInfo,
+	SubscriberInfo,
+	TopicInfo,
+} from '@geekmidas/manifest';

package/dist/CachedStateProvider-CC0DyO09.mjs

@@ -1,3 +0,0 @@
-import { CachedStateProvider } from "./CachedStateProvider-C8A-cCm5.mjs";
-
-export { CachedStateProvider };

package/dist/dokploy-api-BOx71j6F.cjs

@@ -1,3 +0,0 @@
-const require_dokploy_api = require('./dokploy-api-Dvyq-LsM.cjs');
-
-exports.DokployApi = require_dokploy_api.DokployApi;

package/dist/dokploy-api-BZGk-lkD.mjs

@@ -1,3 +0,0 @@
-import { DokployApi, DokployApiError } from "./dokploy-api-BIT0683o.mjs";
-
-export { DokployApi };

package/dist/encryption-Db2zvGqM.mjs

@@ -1,3 +0,0 @@
-import { encryptSecrets, generateDefineOptions } from "./encryption-DSkIlEZ6.mjs";
-
-export { encryptSecrets, generateDefineOptions };