@geekmidas/cli 1.11.0 → 2.0.0

package/src/generators/TopicGenerator.ts

@@ -0,0 +1,45 @@
+import { Topic } from '@geekmidas/constructs/topic';
+import type { BuildContext } from '../build/types';
+import type { TopicInfo } from '../types';
+import {
+	ConstructGenerator,
+	type GeneratedConstruct,
+	type GeneratorOptions,
+} from './Generator';
+
+/**
+ * Discovers `t` topics into `manifest.topics`. A topic is a *resource*, not a
+ * function — it has no handler to generate. Producers reach it via its derived
+ * publisher (`topic.publisher`, whose connection string is sniffed onto the
+ * producing construct) and subscribers bind via `s.topic(topic)`; this generator
+ * only records the topic + its event contract so infra can provision the SNS
+ * topic. Identical output for every provider (locally pg-boss routes by event
+ * name, so there's nothing to run).
+ */
+export class TopicGenerator extends ConstructGenerator<
+	Topic<any, any>,
+	TopicInfo[]
+> {
+	isConstruct(value: any): value is Topic<any, any> {
+		return Topic.isTopic(value);
+	}
+
+	async build(
+		_context: BuildContext,
+		constructs: GeneratedConstruct<Topic<any, any>>[],
+		_outputDir: string,
+		_options?: GeneratorOptions,
+	): Promise<TopicInfo[]> {
+		const logger = console;
+		const topicInfos = constructs.map(({ construct }) => ({
+			name: construct.name,
+			events: construct.eventTypes,
+		}));
+
+		for (const topic of topicInfos) {
+			logger.log(`Discovered topic: ${topic.name}`);
+		}
+
+		return topicInfos;
+	}
+}

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/init/generators/test.ts

@@ -72,7 +72,8 @@ import path from 'node:path';
 import { Credentials } from '@geekmidas/envkit/credentials';
 import { PostgresKyselyMigrator } from '@geekmidas/testkit/kysely';
 import { runInitScript } from '@geekmidas/testkit/postgres';
-import { FileMigrationProvider, Kysely, PostgresDialect } from 'kysely';
+import { Kysely, PostgresDialect } from 'kysely';
+import { FileMigrationProvider } from 'kysely/migration';
 import pg from 'pg';
 
 export default async function globalSetup() {

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': '~6.0.0',
-	'@geekmidas/cloud': '~1.0.1',
-	'@geekmidas/constructs': '~4.0.0',
+	'@geekmidas/client': '~7.0.0',
+	'@geekmidas/cloud': '~1.1.0',
+	'@geekmidas/constructs': '~5.0.0',
 	'@geekmidas/db': '~1.0.2',
 	'@geekmidas/emailkit': '~1.0.1',
-	'@geekmidas/envkit': '~1.0.7',
+	'@geekmidas/envkit': '~1.1.0',
 	'@geekmidas/errors': '~1.0.1',
-	'@geekmidas/events': '~1.1.4',
+	'@geekmidas/events': '~1.1.5',
 	'@geekmidas/logger': '~1.0.2',
-	'@geekmidas/rate-limit': '~3.0.0',
-	'@geekmidas/schema': '~1.0.2',
-	'@geekmidas/services': '~1.1.1',
+	'@geekmidas/rate-limit': '~4.0.0',
+	'@geekmidas/schema': '~1.0.3',
+	'@geekmidas/services': '~2.0.0',
 	'@geekmidas/storage': '~2.0.3',
 	'@geekmidas/studio': '~1.0.1',
 	'@geekmidas/telescope': '~1.0.1',
-	'@geekmidas/testkit': '~2.0.0',
+	'@geekmidas/testkit': '~3.0.0',
 	'@geekmidas/cli': CLI_VERSION,
 } as const;
 

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';