@beesolve/sqs-handler 0.1.8 → 0.1.10

package/README.md

@@ -45,3 +45,8 @@ const sqsHandler = new SqsHandler(stack, "SqsHandler", {
 
 sqsHandler.grantAccess(handler);
 ```
+
+
+
+
+https://logtape.org/manual/install

package/dist/cdk.d.ts

@@ -1,31 +1,64 @@
+import { Nodejs24FunctionProps, SqsWithDlqLambdaInputProps } from "@beesolve/cdk-constructs";
 import { EmailAlarms } from "@beesolve/cdk-email-alarms";
 import { Function } from "aws-cdk-lib/aws-lambda";
-import { NodejsFunction, NodejsFunctionProps } from "aws-cdk-lib/aws-lambda-nodejs";
+import { NodejsFunction } from "aws-cdk-lib/aws-lambda-nodejs";
 import { Construct } from "constructs";
 interface SqsHandlerProps {
 	/**
-	* Path to file where SDK handler is exported.
+	* SqsHandler will deploy NodejsFunction handler.
+	*
+	* This configuration is reused for all additional configurations.
+	* The only required properties are `memorySize`, `timeout` and `entry`.
+	* `entry` should point to file where your handler from `createSqsHandlers` is exported.
+	*
+	* @default
+	*
+	* {
+	*   runtime: Runtime.NODEJS_24_X,
+	*   architecture: Architecture.ARM_64,
+	*   bundling: {
+	*     minify: true,
+	*     sourceMap: true,
+	*     sourcesContent: false,
+	*     target: "es2022",
+	*   }
+	* }
+	*
 	*/
-	readonly entry: string;
+	readonly handlerProps: Nodejs24FunctionProps & Required<Pick<Nodejs24FunctionProps, "memorySize" | "timeout" | "entry">>;
 	/**
-	* When you provide instance of EmailAlarms alarm for your SQS queues and Lambda handler will be set up automatically.
+	* You can set up additional properties through this config.
+	*
+	* For example you can set up FIFO queue here.
 	*/
-	readonly alarms?: EmailAlarms;
+	readonly queueProps?: Omit<SqsWithDlqLambdaInputProps, "lambda">;
 	/**
-	* You can change default memorySize and timeout here.
+	* You can specify additional handler configurations here.
+	*
+	* @example
 	*
-	* @default
 	* {
-	*    memorySize: 1024,
-	*    timeout: Duration.seconds(30)
+	*   longRunning: {
+	*     // memory from `handlerProps` will be reused here
+	*     timeout: Duration.minutes(15)
+	*   },
+	*   multipleCpu: {
+	*     memorySize: 10240,
+	*     timeout: Duration.minutes(5)
+	*   }
 	* }
 	*/
-	readonly handlerProps?: Pick<NodejsFunctionProps, "memorySize" | "timeout">;
+	readonly additionalConfigurations?: Record<string, Pick<Nodejs24FunctionProps, "memorySize" | "timeout">>;
+	/**
+	* If you set up EmailAlarms you can pass it here and alarms for SQS and DLQ will be added automatically.
+	*/
+	readonly alarms?: EmailAlarms;
 }
 declare class SqsHandler extends Construct {
-	private readonly queue;
-	readonly handler: NodejsFunction;
+	private readonly configurations;
 	constructor(scope: Construct, id: string, props: SqsHandlerProps);
 	readonly grantAccess: (grantee: Function) => void;
+	readonly forEachHandler: (callback: (handler: NodejsFunction) => void) => void;
+	private readonly toEnvironmentVariables;
 }
 export { SqsHandlerProps, SqsHandler };

package/dist/cdk.js

@@ -1,42 +1,80 @@
 // packages/sqs-handler/cdk.ts
 import {
-  nodejsFunctionDefaultConfig,
+  Nodejs24Function,
   SqsWithDlq
 } from "@beesolve/cdk-constructs";
-import { Duration } from "aws-cdk-lib";
-import {
-  NodejsFunction
-} from "aws-cdk-lib/aws-lambda-nodejs";
+import { capitalizeFirstLetter } from "@beesolve/helpers";
 import { Construct } from "constructs";
-import { resolve } from "node:path";
-var __dirname = "/Users/ivan/data/work/github.com/beesolve/p/packages/packages/sqs-handler";
+var mainQueueLabel = "main";
 
 class SqsHandler extends Construct {
-  queue;
-  handler;
+  configurations = {};
   constructor(scope, id, props) {
     super(scope, id);
-    const { handlerProps = {} } = props;
-    this.handler = new NodejsFunction(this, "QueueHandler", {
-      description: `${id} queue handler`,
-      entry: resolve(__dirname, props.entry),
-      handler: "handler",
-      memorySize: 1024,
-      timeout: Duration.seconds(30),
-      bundling: nodejsFunctionDefaultConfig.bundling,
-      ...nodejsFunctionDefaultConfig.runtime,
-      ...handlerProps
-    });
-    this.queue = SqsWithDlq.asLambdaInput({
-      lambda: this.handler
+    const {
+      handlerProps,
+      queueProps,
+      additionalConfigurations: additionalHandlerConfigurations = {},
+      alarms
+    } = props;
+    const configurations = {
+      ...additionalHandlerConfigurations,
+      [mainQueueLabel]: {
+        memorySize: handlerProps.memorySize,
+        timeout: handlerProps.timeout
+      }
+    };
+    const { description, memorySize, timeout, ...mainConfig } = handlerProps;
+    for (const [name, config] of Object.entries(configurations)) {
+      const prefix = capitalizeFirstLetter(name);
+      const handlerId = `${prefix}Handler`;
+      const handler = new Nodejs24Function(this, handlerId, {
+        description: `${description ?? "Tasks queue handler"} - ${name}`,
+        ...mainConfig,
+        ...config
+      });
+      const queue = SqsWithDlq.asLambdaInput({
+        lambda: handler,
+        ...queueProps
+      });
+      alarms?.reportSqsErrors(queue);
+      this.configurations[name] = {
+        handler,
+        queue
+      };
+    }
+    const env = this.toEnvironmentVariables();
+    this.forEachHandler((handler) => {
+      env.forEach(({ key, value }) => handler.addEnvironment(key, value));
     });
-    this.handler.addEnvironment("BEESOLVE_TASKS_QUEUE_URL", this.queue.queue.queueUrl);
-    props.alarms?.reportSqsErrors(this.queue);
-    props.alarms?.reportLambdaErrors(this.handler);
   }
   grantAccess = (grantee) => {
-    this.queue.queue.grantSendMessages(grantee);
-    grantee.addEnvironment("BEESOLVE_TASKS_QUEUE_URL", this.queue.queue.queueUrl);
+    Object.values(this.configurations).forEach(({ queue }) => {
+      queue.queue.grantSendMessages(grantee);
+    });
+    const env = this.toEnvironmentVariables();
+    env.forEach(({ key, value }) => grantee.addEnvironment(key, value));
+  };
+  forEachHandler = (callback) => {
+    Object.values(this.configurations).forEach(({ handler }) => callback(handler));
+  };
+  toEnvironmentVariables = () => {
+    const { [mainQueueLabel]: main, ...rest } = this.configurations;
+    if (main == null)
+      throw Error(`Unexpected error. Main queue and handler not set.`);
+    return [
+      {
+        key: "BEESOLVE_TASKS_MAIN_QUEUE_URL",
+        value: main.queue.queue.queueUrl
+      },
+      {
+        key: "BEESOLVE_TASKS_ADDITIONAL_QUEUE_URLS",
+        value: JSON.stringify(Object.fromEntries(Object.entries(rest).map(([key, { queue }]) => [
+          key,
+          queue.queue.queueUrl
+        ])))
+      }
+    ];
   };
 }
 export {

package/dist/index.d.ts

@@ -3,10 +3,12 @@ import { SQSEvent } from "aws-lambda";
 type Functions = Record<string, (...args: any[]) => Promise<void>>;
 declare function createSqsHandlers<
 	TFunctions extends Functions,
+	const TQueueName extends string,
 	Fifo extends boolean
 >(props: {
 	readonly functions: TFunctions;
-	readonly queueUrl: string;
+	readonly queueUrls: Record<TQueueName | "main", string>;
+	readonly queueUrlOverride?: Partial<Record<keyof TFunctions, TQueueName>>;
 	readonly localInvocation?: true;
 	readonly sqsClient: Pick<SQSClient, "send">;
 	readonly fifo: Fifo;
@@ -14,14 +16,18 @@ declare function createSqsHandlers<
 	batchItemFailures: {
 		itemIdentifier: string;
 	}[];
-}>, QueuedFunctions<TFunctions, Fifo>];
+}>, QueuedFunctions<TFunctions, Fifo, TQueueName>];
 type QueuedFunctions<
 	T extends Functions,
-	Fifo extends boolean
-> = { [key in keyof T] : AddParameters<T[key], [fifoOptions?: Fifo extends true ? {
+	Fifo extends boolean,
+	QueueName extends string
+> = { [key in keyof T] : AddParameters<T[key], [options?: Fifo extends true ? {
+	readonly queueName?: QueueName;
 	readonly deduplicationId?: string;
 	readonly groupId?: string;
-} : never]> };
+} : {
+	readonly queueName?: QueueName;
+}]> };
 type AddParameters<
 	TFunction extends (...args: any) => any,
 	TParameters extends [...args: any]

package/dist/index.js

@@ -15,9 +15,12 @@ function createSqsHandlers(props) {
           args: v.array(v.any())
         })), body);
         if (!result.success)
-          throw new Error(`Wrong message format: ${JSON.stringify(v.flatten(result.issues))}`);
+          throw new Error(`Wrong message format: ${JSON.stringify(v.flatten(result.issues), null, 2)}`);
         const { fn, args } = result.output;
-        console.info(JSON.stringify({ function: fn, arguments: args }));
+        console.info({
+          function: fn,
+          arguments: JSON.stringify(args)
+        });
         await props.functions[fn]?.(...args.map((args2) => decodeFromStringifiable(args2)));
       } catch (error) {
         console.error(error);
@@ -28,23 +31,24 @@ function createSqsHandlers(props) {
   };
   const functions = Object.entries(props.functions).reduce((result, [functionName]) => ({
     ...result,
-    async[functionName](...args) {
+    [functionName](...args) {
       const originalFunction = props.functions[functionName];
       if (originalFunction == null)
         throw Error(`Cannot invoke "${functionName}". Make sure the function is defined.`);
       const functionArgs = args.slice(0, originalFunction.length);
-      const fifoOptions = args[originalFunction.length];
+      const options = args[originalFunction.length];
       if (props.localInvocation) {
         originalFunction(...functionArgs);
       } else {
-        await props.sqsClient.send(new SendMessageCommand({
-          QueueUrl: props.queueUrl,
+        const queueUrl = options?.queueName ?? props.queueUrls[props.queueUrlOverride?.[functionName] ?? "main"];
+        props.sqsClient.send(new SendMessageCommand({
+          QueueUrl: queueUrl,
           MessageBody: JSON.stringify({
             fn: functionName,
             args: functionArgs.map((args2) => encodeToStringifiable(args2))
           }),
-          MessageDeduplicationId: fifoOptions?.deduplicationId,
-          MessageGroupId: fifoOptions?.groupId
+          MessageDeduplicationId: options?.deduplicationId,
+          MessageGroupId: options?.groupId
         }));
       }
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@beesolve/sqs-handler",
   "description": "",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "type": "module",
   "files": [
     "dist"
@@ -41,13 +41,13 @@
     }
   },
   "dependencies": {
-    "aws-cdk-lib": "^2.236.0",
+    "aws-cdk-lib": "^2.238.0",
     "constructs": "^10.4.5",
-    "@aws-sdk/client-sqs": "^3.978.0",
+    "@aws-sdk/client-sqs": "^3.990.0",
     "valibot": "^1.2.0",
     "@beesolve/helpers": "0.1.4",
     "@beesolve/cdk-email-alarms": "0.1.1",
-    "@beesolve/cdk-constructs": "0.1.2"
+    "@beesolve/cdk-constructs": "0.1.6"
   },
   "devDependencies": {
     "@types/aws-lambda": "^8.10.160"