@beesolve/sqs-handler 0.1.0

package/README.md

@@ -0,0 +1,13 @@
+# SQS handler
+
+## Installation
+
+Install the latest version of package and its peer dependencies.
+
+```bash
+npm i @beesolve/sqs-handler
+```
+
+## Usage
+
+todo

package/dist/cdk.d.ts

@@ -0,0 +1,23 @@
+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 { Construct } from "constructs";
+interface SqsHandlerProps {
+	/**
+	* Path to file where SDK handler is exported.
+	*/
+	readonly entry: string;
+	/**
+	* @default false
+	*/
+	readonly isProd?: boolean;
+	readonly alarms: EmailAlarms;
+	readonly handlerProps?: Pick<NodejsFunctionProps, "memorySize" | "timeout">;
+}
+declare class SqsHandler extends Construct {
+	private readonly queue;
+	readonly handler: NodejsFunction;
+	constructor(scope: Construct, id: string, props: SqsHandlerProps);
+	readonly grantAccess: (grantee: Function) => void;
+}
+export { SqsHandlerProps, SqsHandler };

package/dist/cdk.js

@@ -0,0 +1,47 @@
+// packages/sqs-handler/cdk.ts
+import { Duration } from "aws-cdk-lib";
+import { Architecture, Runtime } from "aws-cdk-lib/aws-lambda";
+import {
+  NodejsFunction
+} from "aws-cdk-lib/aws-lambda-nodejs";
+import { Construct } from "constructs";
+import { resolve } from "node:path";
+var __dirname = "/Users/ivan/data/work/github.com/beesolve/p/packages/packages/sqs-handler";
+
+class SqsHandler extends Construct {
+  queue;
+  handler;
+  constructor(scope, id, props) {
+    super(scope, id);
+    const { isProd = false, handlerProps = {} } = props;
+    this.handler = new NodejsFunction(this, "QueueHandler", {
+      description: "Tasks queue handler",
+      entry: resolve(__dirname, props.entry),
+      handler: "handler",
+      bundling: {
+        minify: isProd,
+        sourceMap: isProd,
+        sourcesContent: false,
+        target: "es2022"
+      },
+      memorySize: 1024,
+      timeout: Duration.seconds(30),
+      runtime: Runtime.NODEJS_24_X,
+      architecture: Architecture.ARM_64,
+      depsLockFilePath: resolve(`${__dirname}/../../bun.lock`),
+      ...handlerProps
+    });
+    this.queue = SqsWithDlq.asLambdaInput({
+      lambda: this.handler
+    });
+    this.handler.addEnvironment("BEESOLVE_TASKS_QUEUE_URL", this.queue.queue.queueUrl);
+    props.alarms.reportSqsErrors(this.queue);
+  }
+  grantAccess = (grantee) => {
+    this.queue.queue.grantSendMessages(grantee);
+    grantee.addEnvironment("BEESOLVE_TASKS_QUEUE_URL", this.queue.queue.queueUrl);
+  };
+}
+export {
+  SqsHandler
+};

package/dist/index.d.ts

@@ -0,0 +1,29 @@
+import { SQSClient } from "@aws-sdk/client-sqs";
+import { SQSEvent } from "aws-lambda";
+type Functions = Record<string, (...args: any[]) => Promise<void>>;
+declare function createSqsHandlers<
+	TFunctions extends Functions,
+	Fifo extends boolean
+>(props: {
+	readonly functions: TFunctions;
+	readonly queueUrl: string;
+	readonly localInvocation?: true;
+	readonly sqsClient: Pick<SQSClient, "send">;
+	readonly fifo: Fifo;
+}): [(event: SQSEvent) => Promise<{
+	batchItemFailures: {
+		itemIdentifier: string;
+	}[];
+}>, QueuedFunctions<TFunctions, Fifo>];
+type QueuedFunctions<
+	T extends Functions,
+	Fifo extends boolean
+> = { [key in keyof T] : AddParameters<T[key], [fifoOptions?: Fifo extends true ? {
+	readonly deduplicationId?: string;
+	readonly groupId?: string;
+} : never]> };
+type AddParameters<
+	TFunction extends (...args: any) => any,
+	TParameters extends [...args: any]
+> = (...args: [...Parameters<TFunction>, ...TParameters]) => Promise<void>;
+export { createSqsHandlers };

package/dist/index.js

@@ -0,0 +1,59 @@
+// packages/sqs-handler/index.ts
+import { SendMessageCommand } from "@aws-sdk/client-sqs";
+import {
+  decodeFromStringifiable,
+  encodeToStringifiable
+} from "@beesolve/helpers";
+import * as v from "valibot";
+function createSqsHandlers(props) {
+  const handler = async (event) => {
+    const batchItemFailures = new Array;
+    for (const { body, messageId } of event.Records) {
+      try {
+        const result = v.safeParse(v.pipe(v.string(), v.parseJson(), v.object({
+          fName: v.picklist(Object.keys(props.functions)),
+          fArgs: v.array(v.any())
+        })), body);
+        if (!result.success)
+          throw new Error(`Wrong message format: ${JSON.stringify(v.flatten(result.issues), null, 2)}`);
+        const { fName, fArgs } = result.output;
+        console.info({
+          function: fName,
+          arguments: JSON.stringify(fArgs, null, 2)
+        });
+        await props.functions[fName]?.(...fArgs.map((args) => decodeFromStringifiable(args)));
+      } catch (error) {
+        console.error(error);
+        batchItemFailures.push({ itemIdentifier: messageId });
+      }
+    }
+    return { batchItemFailures };
+  };
+  const functions = Object.entries(props.functions).reduce((result, [functionName]) => ({
+    ...result,
+    [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];
+      if (props.localInvocation) {
+        originalFunction(...functionArgs);
+      } else {
+        props.sqsClient.send(new SendMessageCommand({
+          QueueUrl: props.queueUrl,
+          MessageBody: JSON.stringify({
+            fName: functionName,
+            fArgs: functionArgs.map((args2) => encodeToStringifiable(args2))
+          }),
+          MessageDeduplicationId: fifoOptions?.deduplicationId,
+          MessageGroupId: fifoOptions?.groupId
+        }));
+      }
+    }
+  }), {});
+  return [handler, functions];
+}
+export {
+  createSqsHandlers
+};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@beesolve/sqs-handler",
+  "description": "",
+  "version": "0.1.0",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    },
+    "./cdk": {
+      "import": {
+        "types": "./dist/cdk.d.ts",
+        "default": "./dist/cdk.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "homepage": "https://github.com/beesolve/packages/tree/main/packages/sqs-handler#readme",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/beesolve/packages.git"
+  },
+  "scripts": {
+    "type-check": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "typescript": "catalog:"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "aws-cdk-lib": "catalog:",
+    "constructs": "catalog:",
+    "@aws-sdk/client-sqs": "catalog:",
+    "valibot": "catalog:",
+    "@beesolve/helpers": "workspace:*",
+    "@beesolve/cdk-email-alarms": "workspace:*",
+    "@beesolve/cdk-constructs": "workspace:*"
+  },
+  "devDependencies": {
+    "@types/aws-lambda": "catalog:"
+  }
+}