@geekmidas/cli 1.11.0 → 2.0.0

package/dist/index.mjs

@@ -6,7 +6,7 @@ import { getCredentialsPath, getDokployCredentials, getDokployRegistryId, getDok
 import { createStageSecrets, generateDbPassword, generateDbUrl, generateFullstackCustomSecrets, rotateServicePassword } from "./fullstack-secrets-l8s3II_H.mjs";
 import { getKeyPath, maskPassword, readStageSecrets, secretsExist, setCustomSecret, toEmbeddableSecrets, writeStageSecrets } from "./storage-dbb9RyBl.mjs";
 import { createCredentialsPreload, createEntryWrapper, findAvailablePort, isPortAvailable, loadEnvFiles, loadSecretsForApp, prepareEntryCredentials, resolveServicePorts, rewriteUrlsWithPorts, setupCommand, startWorkspaceServices } from "./setup-DDXUXzzl.mjs";
-import { ConstructGenerator, EndpointGenerator, OPENAPI_OUTPUT_PATH, generateOpenApi, isPartitionedRoutes, normalizeRoutes, openapiCommand, resolveOpenApiConfig } from "./openapi-CtRVU6RD.mjs";
+import { ConstructGenerator, EndpointGenerator, OPENAPI_OUTPUT_PATH, generateOpenApi, isPartitionedRoutes, normalizeRoutes, openapiCommand, resolveOpenApiConfig } from "./openapi-Cfwi0fqF.mjs";
 import { DokployApi } from "./dokploy-api-sfZFlWuE.mjs";
 import { encryptSecrets } from "./encryption-CO5Q4Bhf.mjs";
 import { CachedStateProvider } from "./CachedStateProvider-CzyFct42.mjs";
@@ -26,7 +26,9 @@ import { parse as parse$1 } from "yaml";
 import { randomBytes } from "node:crypto";
 import { Cron } from "@geekmidas/constructs/crons";
 import { Function } from "@geekmidas/constructs/functions";
+import { Queue } from "@geekmidas/constructs/queue";
 import { Subscriber } from "@geekmidas/constructs/subscribers";
+import { Topic } from "@geekmidas/constructs/topic";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { Client } from "pg";
 import { lookup } from "node:dns/promises";
@@ -34,7 +36,7 @@ import prompts from "prompts";
 
 //#region package.json
 var name = "@geekmidas/cli";
-var version = "1.10.41";
+var version = "1.12.0";
 var description = "CLI tools for building Lambda handlers, server applications, and generating OpenAPI specs";
 var private$1 = false;
 var type = "module";
@@ -114,6 +116,7 @@ var dependencies = {
 	"@geekmidas/envkit": "workspace:~",
 	"@geekmidas/errors": "workspace:~",
 	"@geekmidas/logger": "workspace:~",
+	"@geekmidas/manifest": "workspace:*",
 	"@geekmidas/schema": "workspace:~",
 	"chokidar": "~4.0.3",
 	"commander": "^12.1.0",
@@ -461,6 +464,176 @@ export const handler = adapter.handler;
 	}
 };
 
+//#endregion
+//#region src/generators/QueueGenerator.ts
+/**
+* Generates the runtime for `q` queue workers.
+*
+* - **server** (`gkm dev`): a single `queues.ts` exposing `setupQueues()` that
+*   runs an in-process pg-boss poller alongside the Hono server — no SQS/Lambda.
+*   Each queue subscribes by its **name** on the shared event connection.
+* - **aws-lambda**: one handler file per queue wrapping `AWSLambdaQueue`, backed
+*   by an SQS event-source mapping.
+*/
+var QueueGenerator = class extends ConstructGenerator {
+	isConstruct(value) {
+		return Queue.isQueue(value);
+	}
+	async build(context, constructs, outputDir, options) {
+		const provider = options?.provider || "aws-lambda";
+		const logger$13 = console;
+		const queueInfos = [];
+		if (provider === "server") {
+			await this.generateServerQueuesFile(outputDir, constructs);
+			logger$13.log(`Generated server queues file with ${constructs.length} queues (polling mode)`);
+			return queueInfos;
+		}
+		if (constructs.length === 0 || provider !== "aws-lambda") return queueInfos;
+		const queuesDir = join(outputDir, "queues");
+		await mkdir(queuesDir, { recursive: true });
+		for (const { key, construct, path } of constructs) {
+			const handlerFile = await this.generateQueueHandler(queuesDir, path.relative, key, context);
+			queueInfos.push({
+				name: construct.name,
+				handler: relative(process.cwd(), handlerFile).replace(/\.ts$/, ".handler"),
+				batchSize: construct.batchSize,
+				fifo: construct.fifo,
+				timeout: construct.timeout,
+				environment: await construct.getEnvironment({ markOptional: context.markOptional })
+			});
+			logger$13.log(`Generated queue handler: ${key}`);
+		}
+		return queueInfos;
+	}
+	async generateQueueHandler(outputDir, sourceFile, exportName, context) {
+		const handlerPath = join(outputDir, `${exportName}.ts`);
+		const importPath = relative(dirname(handlerPath), sourceFile).replace(/\.ts$/, ".js");
+		const relativeEnvParserPath = relative(dirname(handlerPath), context.envParserPath);
+		const content = `import { AWSLambdaQueue } from '@geekmidas/constructs/aws';
+import { ${exportName} } from '${importPath}';
+import ${context.envParserImportPattern} from '${relativeEnvParserPath}';
+
+const adapter = new AWSLambdaQueue(envParser, ${exportName});
+
+export const handler = adapter.handler;
+`;
+		await writeFile(handlerPath, content);
+		return handlerPath;
+	}
+	async generateServerQueuesFile(outputDir, queues) {
+		await mkdir(outputDir, { recursive: true });
+		const queuesPath = join(outputDir, "queues.ts");
+		const importsByFile = /* @__PURE__ */ new Map();
+		for (const { path, key } of queues) {
+			const importPath = relative(dirname(queuesPath), path.relative).replace(/\.ts$/, ".js");
+			if (!importsByFile.has(importPath)) importsByFile.set(importPath, []);
+			importsByFile.get(importPath)?.push(key);
+		}
+		const imports = Array.from(importsByFile.entries()).map(([importPath, exports$1]) => `import { ${exports$1.join(", ")} } from '${importPath}';`).join("\n");
+		const allExportNames = queues.map(({ key }) => key);
+		const content = `/**
+ * Generated queue workers setup
+ *
+ * ⚠️  WARNING: This is for LOCAL DEVELOPMENT ONLY
+ * This runs an in-process pg-boss poller alongside the HTTP server. Each queue
+ * subscribes by its name on the shared event connection
+ * (EVENT_SUBSCRIBER_CONNECTION_STRING), so producers using
+ * <NAME>_PUBLISHER_CONNECTION_STRING (pgboss:// locally) reach it.
+ *
+ * For production, queues run as AWS Lambda with SQS event-source mappings.
+ */
+import type { EnvironmentParser } from '@geekmidas/envkit';
+import type { Logger } from '@geekmidas/logger';
+import { EventConnectionFactory, Subscriber } from '@geekmidas/events';
+import type { EventConnection, EventSubscriber } from '@geekmidas/events';
+import { ServiceDiscovery } from '@geekmidas/services';
+${imports}
+
+const queues = [
+  ${allExportNames.join(",\n  ")}
+];
+
+const activeSubscribers: EventSubscriber<any>[] = [];
+
+export async function setupQueues(
+  envParser: EnvironmentParser<any>,
+  logger: Logger,
+): Promise<void> {
+  if (queues.length === 0) {
+    return;
+  }
+
+  logger.info('Setting up queue workers in polling mode (local development)');
+
+  const config = envParser.create((get) => ({
+    connectionString: get('EVENT_SUBSCRIBER_CONNECTION_STRING').string(),
+  })).parse();
+
+  const serviceDiscovery = ServiceDiscovery.getInstance(envParser);
+
+  let connection: EventConnection;
+  try {
+    connection = await EventConnectionFactory.fromConnectionString(config.connectionString);
+    const connectionType = new URL(config.connectionString).protocol.replace(':', '');
+    logger.info({ connectionType }, 'Created shared event connection for queues');
+  } catch (error) {
+    logger.error({ error }, 'Failed to create event connection for queues');
+    return;
+  }
+
+  for (const queue of queues) {
+    try {
+      const eventSubscriber = await Subscriber.fromConnection(connection);
+
+      const services = queue.services.length > 0
+        ? await serviceDiscovery.register(queue.services)
+        : {};
+
+      // A queue subscribes to a single "type" — its own name.
+      await eventSubscriber.subscribe([queue.name], async (message) => {
+        try {
+          const validation = await queue.messageSchema['~standard'].validate(message.payload);
+          if (validation.issues) {
+            logger.error({ issues: validation.issues, queue: queue.name }, 'Queue message failed validation');
+            return;
+          }
+
+          await queue.handler({
+            messages: [validation.value],
+            services: services,
+            logger: queue.logger,
+          });
+
+          logger.debug({ queue: queue.name }, 'Successfully processed queue message');
+        } catch (error) {
+          logger.error({ error, queue: queue.name }, 'Failed to process queue message');
+          // Message will become visible again for retry.
+        }
+      });
+
+      activeSubscribers.push(eventSubscriber);
+      logger.info({ queue: queue.name }, 'Queue worker started polling');
+    } catch (error) {
+      logger.error({ error, queue: queue.name }, 'Failed to setup queue worker');
+    }
+  }
+
+  const shutdown = () => {
+    logger.info('Stopping all queue workers');
+    for (const _ of activeSubscribers) {
+      connection.stop();
+    }
+  };
+
+  process.on('SIGTERM', shutdown);
+  process.on('SIGINT', shutdown);
+}
+`;
+		await writeFile(queuesPath, content);
+		return queuesPath;
+	}
+};
+
 //#endregion
 //#region src/generators/SubscriberGenerator.ts
 var SubscriberGenerator = class extends ConstructGenerator {
@@ -486,6 +659,10 @@ var SubscriberGenerator = class extends ConstructGenerator {
 				name: key,
 				handler: relative(process.cwd(), handlerFile).replace(/\.ts$/, ".handler"),
 				subscribedEvents: construct.subscribedEvents || [],
+				...construct.topicName ? {
+					transport: "topic",
+					topic: construct.topicName
+				} : {},
 				timeout: construct.timeout,
 				memorySize: construct.memorySize,
 				environment: await construct.getEnvironment({ markOptional: context.markOptional })
@@ -654,6 +831,32 @@ export async function setupSubscribers(
 	}
 };
 
+//#endregion
+//#region src/generators/TopicGenerator.ts
+/**
+* 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).
+*/
+var TopicGenerator = class extends ConstructGenerator {
+	isConstruct(value) {
+		return Topic.isTopic(value);
+	}
+	async build(_context, constructs, _outputDir, _options) {
+		const logger$13 = console;
+		const topicInfos = constructs.map(({ construct }) => ({
+			name: construct.name,
+			events: construct.eventTypes
+		}));
+		for (const topic of topicInfos) logger$13.log(`Discovered topic: ${topic.name}`);
+		return topicInfos;
+	}
+};
+
 //#endregion
 //#region src/exec/index.ts
 const logger$11 = console;
@@ -1321,11 +1524,15 @@ async function buildServer(config, context, provider, enableOpenApi, appRoot = p
 	const functionGenerator = new FunctionGenerator();
 	const cronGenerator = new CronGenerator();
 	const subscriberGenerator = new SubscriberGenerator();
-	const [allEndpoints, allFunctions, allCrons, allSubscribers] = await Promise.all([
+	const queueGenerator = new QueueGenerator();
+	const topicGenerator = new TopicGenerator();
+	const [allEndpoints, allFunctions, allCrons, allSubscribers, allQueues, allTopics] = await Promise.all([
 		endpointGenerator.load(config.routes, appRoot, bustCache),
 		config.functions ? functionGenerator.load(config.functions, appRoot, bustCache) : [],
 		config.crons ? cronGenerator.load(config.crons, appRoot, bustCache) : [],
-		config.subscribers ? subscriberGenerator.load(config.subscribers, appRoot, bustCache) : []
+		config.subscribers ? subscriberGenerator.load(config.subscribers, appRoot, bustCache) : [],
+		config.queues ? queueGenerator.load(config.queues, appRoot, bustCache) : [],
+		config.topics ? topicGenerator.load(config.topics, appRoot, bustCache) : []
 	]);
 	const outputDir = join(appRoot, ".gkm", provider);
 	await mkdir(outputDir, { recursive: true });
@@ -1336,7 +1543,9 @@ async function buildServer(config, context, provider, enableOpenApi, appRoot = p
 		}),
 		functionGenerator.build(context, allFunctions, outputDir, { provider }),
 		cronGenerator.build(context, allCrons, outputDir, { provider }),
-		subscriberGenerator.build(context, allSubscribers, outputDir, { provider })
+		subscriberGenerator.build(context, allSubscribers, outputDir, { provider }),
+		queueGenerator.build(context, allQueues, outputDir, { provider }),
+		topicGenerator.build(context, allTopics, outputDir, { provider })
 	]);
 }
 /**
@@ -1667,7 +1876,7 @@ function generateDerivedType(fieldName, typeName, partitioned) {
 	}
 	return `export type ${typeName} = (typeof manifest.${fieldName})[number];`;
 }
-async function generateAwsManifest(outputDir, routes, functions, crons, subscribers) {
+async function generateAwsManifest(outputDir, routes, functions, crons, subscribers, queues = [], topics = []) {
 	const manifestDir = join(outputDir, "manifest");
 	await mkdir(manifestDir, { recursive: true });
 	const awsRoutes = filterAllRoutes(routes);
@@ -1675,11 +1884,15 @@ async function generateAwsManifest(outputDir, routes, functions, crons, subscrib
 	const functionsPartitioned = isPartitioned(functions);
 	const cronsPartitioned = isPartitioned(crons);
 	const subscribersPartitioned = isPartitioned(subscribers);
+	const queuesPartitioned = isPartitioned(queues);
+	const topicsPartitioned = isPartitioned(topics);
 	const content = `export const manifest = {
   routes: ${serializeField(awsRoutes)},
   functions: ${serializeField(functions)},
   crons: ${serializeField(crons)},
   subscribers: ${serializeField(subscribers)},
+  queues: ${serializeField(queues)},
+  topics: ${serializeField(topics)},
 } as const;
 
 // Derived types
@@ -1687,6 +1900,8 @@ ${generateDerivedType("routes", "Route", routesPartitioned)}
 ${generateDerivedType("functions", "Function", functionsPartitioned)}
 ${generateDerivedType("crons", "Cron", cronsPartitioned)}
 ${generateDerivedType("subscribers", "Subscriber", subscribersPartitioned)}
+${generateDerivedType("queues", "Queue", queuesPartitioned)}
+${generateDerivedType("topics", "Topic", topicsPartitioned)}
 
 // Useful union types
 export type Authorizer = Route['authorizer'];
@@ -1695,25 +1910,33 @@ export type RoutePath = Route['path'];
 `;
 	const manifestPath = join(manifestDir, "aws.ts");
 	await writeFile(manifestPath, content);
-	logger$9.log(`Generated AWS manifest with ${countItems(awsRoutes)} routes, ${countItems(functions)} functions, ${countItems(crons)} crons, ${countItems(subscribers)} subscribers`);
+	logger$9.log(`Generated AWS manifest with ${countItems(awsRoutes)} routes, ${countItems(functions)} functions, ${countItems(crons)} crons, ${countItems(subscribers)} subscribers, ${countItems(queues)} queues, ${countItems(topics)} topics`);
 	logger$9.log(`Manifest: ${relative(process.cwd(), manifestPath)}`);
 }
-async function generateServerManifest(outputDir, appInfo, routes, subscribers) {
+async function generateServerManifest(outputDir, appInfo, routes, subscribers, queues = [], topics = []) {
 	const manifestDir = join(outputDir, "manifest");
 	await mkdir(manifestDir, { recursive: true });
 	const serverRoutes = mapRouteMetadata(filterAllRoutes(routes));
 	const serverSubscribers = mapSubscriberMetadata(subscribers);
+	const serverQueues = mapQueueMetadata(queues);
+	const serverTopics = mapTopicMetadata(topics);
 	const routesPartitioned = isPartitioned(serverRoutes);
 	const subscribersPartitioned = isPartitioned(serverSubscribers);
+	const queuesPartitioned = isPartitioned(serverQueues);
+	const topicsPartitioned = isPartitioned(serverTopics);
 	const content = `export const manifest = {
   app: ${JSON.stringify(appInfo, null, 2)},
   routes: ${serializeField(serverRoutes)},
   subscribers: ${serializeField(serverSubscribers)},
+  queues: ${serializeField(serverQueues)},
+  topics: ${serializeField(serverTopics)},
 } as const;
 
 // Derived types
 ${generateDerivedType("routes", "Route", routesPartitioned)}
 ${generateDerivedType("subscribers", "Subscriber", subscribersPartitioned)}
+${generateDerivedType("queues", "Queue", queuesPartitioned)}
+${generateDerivedType("topics", "Topic", topicsPartitioned)}
 
 // Useful union types
 export type Authorizer = Route['authorizer'];
@@ -1722,7 +1945,7 @@ export type RoutePath = Route['path'];
 `;
 	const manifestPath = join(manifestDir, "server.ts");
 	await writeFile(manifestPath, content);
-	logger$9.log(`Generated server manifest with ${countItems(serverRoutes)} routes, ${countItems(serverSubscribers)} subscribers`);
+	logger$9.log(`Generated server manifest with ${countItems(serverRoutes)} routes, ${countItems(serverSubscribers)} subscribers, ${countItems(serverQueues)} queues, ${countItems(serverTopics)} topics`);
 	logger$9.log(`Manifest: ${relative(process.cwd(), manifestPath)}`);
 }
 /**
@@ -1761,6 +1984,23 @@ function mapSubscriberMetadata(subscribers) {
 	for (const [partition, partitionSubs] of Object.entries(subscribers)) result[partition] = partitionSubs.map(mapFn);
 	return result;
 }
+function mapQueueMetadata(queues) {
+	const mapFn = (q) => ({ name: q.name });
+	if (Array.isArray(queues)) return queues.map(mapFn);
+	const result = {};
+	for (const [partition, partitionQueues] of Object.entries(queues)) result[partition] = partitionQueues.map(mapFn);
+	return result;
+}
+function mapTopicMetadata(topics) {
+	const mapFn = (t) => ({
+		name: t.name,
+		events: t.events
+	});
+	if (Array.isArray(topics)) return topics.map(mapFn);
+	const result = {};
+	for (const [partition, partitionTopics] of Object.entries(topics)) result[partition] = partitionTopics.map(mapFn);
+	return result;
+}
 
 //#endregion
 //#region src/build/partitions.ts
@@ -1846,47 +2086,57 @@ async function buildCommand(options) {
 	const functionGenerator = new FunctionGenerator();
 	const cronGenerator = new CronGenerator();
 	const subscriberGenerator = new SubscriberGenerator();
-	const [allEndpoints, allFunctions, allCrons, allSubscribers] = await Promise.all([
+	const queueGenerator = new QueueGenerator();
+	const topicGenerator = new TopicGenerator();
+	const [allEndpoints, allFunctions, allCrons, allSubscribers, allQueues, allTopics] = await Promise.all([
 		endpointGenerator.load(config.routes),
 		config.functions ? functionGenerator.load(config.functions) : [],
 		config.crons ? cronGenerator.load(config.crons) : [],
-		config.subscribers ? subscriberGenerator.load(config.subscribers) : []
+		config.subscribers ? subscriberGenerator.load(config.subscribers) : [],
+		config.queues ? queueGenerator.load(config.queues) : [],
+		config.topics ? topicGenerator.load(config.topics) : []
 	]);
 	logger$8.log(`Found ${allEndpoints.length} endpoints`);
 	logger$8.log(`Found ${allFunctions.length} functions`);
 	logger$8.log(`Found ${allCrons.length} crons`);
 	logger$8.log(`Found ${allSubscribers.length} subscribers`);
-	if (allEndpoints.length === 0 && allFunctions.length === 0 && allCrons.length === 0 && allSubscribers.length === 0) {
-		logger$8.log("No endpoints, functions, crons, or subscribers found to process");
+	logger$8.log(`Found ${allQueues.length} queues`);
+	logger$8.log(`Found ${allTopics.length} topics`);
+	if (allEndpoints.length === 0 && allFunctions.length === 0 && allCrons.length === 0 && allSubscribers.length === 0 && allQueues.length === 0 && allTopics.length === 0) {
+		logger$8.log("No endpoints, functions, crons, subscribers, queues, or topics found to process");
 		return {};
 	}
 	const rootOutputDir = join(process.cwd(), ".gkm");
 	await mkdir(rootOutputDir, { recursive: true });
 	let result = {};
 	for (const provider of resolved.providers) {
-		const providerResult = await buildForProvider(provider, buildContext, rootOutputDir, endpointGenerator, functionGenerator, cronGenerator, subscriberGenerator, allEndpoints, allFunctions, allCrons, allSubscribers, resolved.enableOpenApi, options.skipBundle ?? false, options.stage);
+		const providerResult = await buildForProvider(provider, buildContext, rootOutputDir, endpointGenerator, functionGenerator, cronGenerator, subscriberGenerator, queueGenerator, topicGenerator, allEndpoints, allFunctions, allCrons, allSubscribers, allQueues, allTopics, resolved.enableOpenApi, options.skipBundle ?? false, options.stage);
 		if (providerResult.masterKey) result = providerResult;
 	}
 	await generateOpenApi(config, { bustCache: true });
 	return result;
 }
-async function buildForProvider(provider, context, rootOutputDir, endpointGenerator, functionGenerator, cronGenerator, subscriberGenerator, endpoints, functions, crons, subscribers, enableOpenApi, skipBundle, stage) {
+async function buildForProvider(provider, context, rootOutputDir, endpointGenerator, functionGenerator, cronGenerator, subscriberGenerator, queueGenerator, topicGenerator, endpoints, functions, crons, subscribers, queues, topics, enableOpenApi, skipBundle, stage) {
 	const outputDir = join(process.cwd(), ".gkm", provider);
 	await mkdir(outputDir, { recursive: true });
 	logger$8.log(`\nGenerating handlers for provider: ${provider}`);
-	const [routes, functionInfos, cronInfos, subscriberInfos] = await Promise.all([
+	const [routes, functionInfos, cronInfos, subscriberInfos, queueInfos, topicInfos] = await Promise.all([
 		endpointGenerator.build(context, endpoints, outputDir, {
 			provider,
 			enableOpenApi
 		}),
 		functionGenerator.build(context, functions, outputDir, { provider }),
 		cronGenerator.build(context, crons, outputDir, { provider }),
-		subscriberGenerator.build(context, subscribers, outputDir, { provider })
+		subscriberGenerator.build(context, subscribers, outputDir, { provider }),
+		queueGenerator.build(context, queues, outputDir, { provider }),
+		topicGenerator.build(context, topics, outputDir, { provider })
 	]);
-	logger$8.log(`Generated ${routes.length} routes, ${functionInfos.length} functions, ${cronInfos.length} crons, ${subscriberInfos.length} subscribers for ${provider}`);
+	logger$8.log(`Generated ${routes.length} routes, ${functionInfos.length} functions, ${cronInfos.length} crons, ${subscriberInfos.length} subscribers, ${queueInfos.length} queues, ${topicInfos.length} topics for ${provider}`);
 	const manifestRoutes = assembleManifestField(routes, endpoints);
 	const manifestFunctions = assembleManifestField(functionInfos, functions);
 	const manifestCrons = assembleManifestField(cronInfos, crons);
+	const manifestQueues = assembleManifestField(queueInfos, queues);
+	const manifestTopics = assembleManifestField(topicInfos, topics);
 	const manifestSubscribers = assembleManifestField(subscriberInfos, subscribers);
 	if (provider === "server") {
 		const routeMetadata = await Promise.all(endpoints.map(async ({ construct }) => ({
@@ -1900,7 +2150,7 @@ async function buildForProvider(provider, context, rootOutputDir, endpointGenera
 			handler: relative(process.cwd(), join(outputDir, "app.ts")),
 			endpoints: relative(process.cwd(), join(outputDir, "endpoints.ts"))
 		};
-		await generateServerManifest(rootOutputDir, appInfo, serverRouteField, manifestSubscribers);
+		await generateServerManifest(rootOutputDir, appInfo, serverRouteField, manifestSubscribers, manifestQueues, manifestTopics);
 		let masterKey;
 		if (context.production?.bundle && !skipBundle) {
 			logger$8.log(`\n📦 Bundling production server...`);
@@ -1909,7 +2159,8 @@ async function buildForProvider(provider, context, rootOutputDir, endpointGenera
 				...endpoints.map((e) => e.construct),
 				...functions.map((f) => f.construct),
 				...crons.map((c) => c.construct),
-				...subscribers.map((s) => s.construct)
+				...subscribers.map((s) => s.construct),
+				...queues.map((q) => q.construct)
 			];
 			const dockerServices = context.dockerServices;
 			const bundleResult = await bundleServer({
@@ -1930,7 +2181,7 @@ async function buildForProvider(provider, context, rootOutputDir, endpointGenera
 			}
 		}
 		return { masterKey };
-	} else await generateAwsManifest(rootOutputDir, manifestRoutes, manifestFunctions, manifestCrons, manifestSubscribers);
+	} else await generateAwsManifest(rootOutputDir, manifestRoutes, manifestFunctions, manifestCrons, manifestSubscribers, manifestQueues, manifestTopics);
 	return {};
 }
 /**
@@ -6647,22 +6898,22 @@ 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
 };
 
@@ -9710,7 +9961,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() {