@tomassabol/aws-services 1.8.0

package/.eslintignore

@@ -0,0 +1 @@
+dist

package/.eslintrc.json

@@ -0,0 +1,75 @@
+{
+  "root": true,
+  "env": {
+    "node": true
+  },
+  "overrides": [
+    {
+      "files": ["**/*.ts", "**/*.tsx"],
+      "parser": "@typescript-eslint/parser",
+      "parserOptions": {
+        "project": "./tsconfig.json"
+      },
+      "plugins": ["@typescript-eslint"],
+      "extends": [
+        "eslint:recommended",
+        "plugin:import/recommended",
+        "plugin:import/typescript",
+        "plugin:@typescript-eslint/eslint-recommended",
+        "plugin:@typescript-eslint/recommended",
+        "prettier"
+      ],
+      "rules": {
+        "@typescript-eslint/no-empty-interface": "warn",
+        "@typescript-eslint/no-unused-vars": [
+          "warn",
+          { "argsIgnorePattern": "^_" }
+        ],
+        "@typescript-eslint/no-floating-promises": "error",
+        "require-await": "warn",
+        "no-useless-catch": "warn",
+        "no-console": "warn",
+        "no-new-object": "warn",
+        "object-shorthand": ["warn", "always"],
+        "quote-props": ["warn", "as-needed"],
+        "prefer-object-spread": "warn",
+        "prefer-destructuring": [
+          "warn",
+          {
+            "VariableDeclarator": {
+              "array": false,
+              "object": true
+            },
+            "AssignmentExpression": {
+              "array": false,
+              "object": false
+            }
+          }
+        ],
+        "default-param-last": "warn",
+        "no-param-reassign": [
+          "warn",
+          { "props": true, "ignorePropertyModificationsFor": ["acc"] }
+        ],
+        "prefer-arrow-callback": "warn",
+        "no-duplicate-imports": "warn",
+        "import/no-mutable-exports": "warn",
+        "import/first": "warn",
+        "no-iterator": "warn",
+        "dot-notation": "warn",
+        "one-var": ["warn", { "initialized": "never" }],
+        "no-multi-assign": "warn",
+        "no-plusplus": ["warn", { "allowForLoopAfterthoughts": true }],
+        "eqeqeq": "warn"
+      }
+    },
+    {
+      "files": ["**/*.md"],
+      "extends": "plugin:markdown/recommended"
+    },
+    {
+      "files": ["**/*.json"],
+      "extends": "plugin:json/recommended"
+    }
+  ]
+}

package/.husky/pre-commit

@@ -0,0 +1,4 @@
+#!/bin/sh
+. "$(dirname "$0")/_/husky.sh"
+
+npx lint-staged

package/.lintstagedrc.json

@@ -0,0 +1,9 @@
+{
+  "*.ts": [
+    "tsc --noEmit --esModuleInterop --skipLibCheck --resolveJsonModule --target es2022 --module commonjs"
+  ],
+  "*.{js,ts,json,md}": [
+    "eslint --no-ignore --max-warnings 0",
+    "prettier --write"
+  ]
+}

package/.nvmrc

@@ -0,0 +1 @@
+v18.18.2

package/.prettierignore

@@ -0,0 +1,2 @@
+.coverage
+dist

package/.prettierrc.json

@@ -0,0 +1,3 @@
+{
+  "semi": false
+}

package/.vscode/settings.json

@@ -0,0 +1,6 @@
+{
+  "sonarlint.connectedMode.project": {
+    "connectionId": "io.tomassabol.sonarqube",
+    "projectKey": "tomassaboldev_aws-services_bb5f4f68-64f8-4726-bdd4-579ceadf172d"
+  }
+}

package/CHANGELOG.md

@@ -0,0 +1,96 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.8.0] - 2024-06-24
+
+### Changed
+
+- WMS-488 Improve sendEvent error handling
+
+## [1.7.1] - 2024-06-22
+
+### Changed
+
+- Bump @aws-lambda-powertools/logger
+
+### Security
+
+- Remove NPM token
+
+## [1.7.0] - 2023-11-18
+
+### Added
+
+- Add Jest mock for SSM
+
+## [1.6.1] - 2023-11-04
+
+### Added
+
+- Add getSecret method to Secrets Manager mock
+
+### Security
+
+- Fix vulnerabilities
+
+## [1.6.0] - 2023-08-18
+
+### Added
+
+- Add Jest mocks for DynamoDB, EventBridge, Secrets Manager and SQS
+
+## [1.5.0] - 2023-08-14
+
+### Changed
+
+- Improve S3 client
+
+## [1.4.0] - 2023-08-12
+
+### Changed
+
+- Improve EventBridge client
+
+## [1.3.0] - 2023-08-11
+
+### Added
+
+- Add format check step to Bitbucket pipeline
+- Add nvm configuration file
+
+### Changed
+
+- Improve SSM client
+- Improve SQS client
+- Improve Secrets Manager client
+- Improve DynamoDB client
+- Upgrade AWS CDK libs
+- Refactor NPM scripts
+- Update nvm configuration file
+- Improve Bitbucket pipeline
+
+### Removed
+
+- Remove npm-run-all package
+
+### Security
+
+- Fix vulnerabilities
+
+## [1.2.1] - 2023-06-08
+
+### Fixed
+
+- Fix importing without dist folder
+
+### Security
+
+- Fix vulnerabilities
+
+## [1.1.1]
+
+- Initial release

package/README.md

@@ -0,0 +1,28 @@
+# AWS Services
+
+## How to publish
+
+To be able to import from path `@tomassabol/aws-services/s3` and not `@tomassabol/aws-services/dist/s3`, you have to publish the package with following command:
+
+```sh
+npm run dist
+```
+
+## How to use it
+
+```sh
+npm install @tomassabol/aws-services
+```
+
+```typescript
+import { getFromS3 } from "@tomassabol/aws-services/s3"
+
+async function getMyObject() {
+  const params = {
+    bucket: "my-bucket-name",
+    key: "my-object-key",
+  }
+
+  const data = await getFromS3(params)
+}
+```

package/bitbucket-pipelines.yml

@@ -0,0 +1,65 @@
+image: node:18
+
+definitions:
+  steps:
+    - step: &build-step
+        name: Build
+        caches:
+          - node
+        script:
+          - npm ci
+    - step: &format-step
+        name: Format
+        caches:
+          - node
+        script:
+          - npm run format
+    - step: &lint-step
+        name: Lint
+        caches:
+          - node
+        script:
+          - npm run lint
+    - step: &test-step
+        name: Test
+        caches:
+          - node
+        script:
+          - npm test
+        artifacts:
+          - .coverage/lcov.info
+          - .sonar/test-report.xml
+    - step: &code-analysis-step
+        name: Code Analysis
+        caches:
+          - sonar
+        script:
+          - pipe: sonarsource/sonarqube-scan:2.0.1
+            variables:
+              SONAR_HOST_URL: ${SONAR_HOST_URL}
+              SONAR_TOKEN: ${SONAR_TOKEN}
+
+  caches:
+    sonar: /opt/sonar-scanner/.sonar
+
+clone:
+  depth: full
+
+pipelines:
+  branches:
+    "{main,test,prod}":
+      - step: *build-step
+      - parallel:
+          - step: *format-step
+          - step: *lint-step
+          - step: *test-step
+      - step: *code-analysis-step
+
+  pull-requests:
+    "**":
+      - step: *build-step
+      - parallel:
+          - step: *format-step
+          - step: *lint-step
+          - step: *test-step
+      - step: *code-analysis-step

package/jest.config.js

@@ -0,0 +1,62 @@
+/*
+ * For a detailed explanation regarding each configuration property and type check, visit:
+ * https://jestjs.io/docs/en/configuration.html
+ */
+
+module.exports = {
+  /**
+   * Paths
+   */
+
+  // A list of paths to directories that Jest should use to search for files in
+  roots: ["./test"],
+
+  // The glob patterns Jest uses to detect test files
+  testMatch: ["<rootDir>/test/**/*.test.ts"],
+
+  // Transformers for files
+  transform: {
+    "^.+\\.tsx?$": [
+      "esbuild-jest",
+      {
+        sourcemap: true,
+      },
+    ],
+  },
+
+  /*
+   * Results processing
+   */
+
+  // Indicates whether the coverage information should be collected while executing the test
+  collectCoverage: true,
+
+  // An array of glob patterns indicating a set of files for which coverage information should be collected
+  collectCoverageFrom: ["src/**/*.ts"],
+
+  // An array of regexp pattern strings used to skip coverage for certain files
+  coveragePathIgnorePatterns: ["src/logger.ts"],
+
+  // The directory where Jest should output its coverage files
+  coverageDirectory: ".coverage",
+
+  // Export test results fo SonarQube scanner to process test results
+  testResultsProcessor: "jest-sonar-reporter",
+
+  /*
+   * Test environment
+   */
+
+  // The test environment that will be used for testing
+  testEnvironment: "node",
+
+  // Run for all tests
+  // setupFiles: ["<rootDir>/test/env.ts"],
+
+  /*
+   * Mocks
+   */
+
+  // Automatically clear mock calls and instances between every test
+  clearMocks: true,
+}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@tomassabol/aws-services",
+  "version": "1.8.0",
+  "license": "MIT",
+  "description": "AWS Services",
+  "scripts": {
+    "build": "tsc -b tsconfig.build.json",
+    "clean": "rimraf dist .coverage .sonar",
+    "coverage": "open .coverage/lcov-report/index.html",
+    "dist": "tsc -b tsconfig.build.json && cp package.json dist && cp README.md dist && cd dist && npm publish",
+    "format": "prettier --check .",
+    "husky-install": "husky install",
+    "lint": "eslint . --max-warnings 0",
+    "test": "jest"
+  },
+  "peerDependencies": {
+    "@aws-lambda-powertools/logger": "^2.2.0",
+    "@aws-sdk/client-appconfig": "^3.388.0",
+    "@aws-sdk/client-dynamodb": "^3.388.0",
+    "@aws-sdk/client-eventbridge": "^3.388.0",
+    "@aws-sdk/client-s3": "^3.388.0",
+    "@aws-sdk/client-secrets-manager": "^3.388.0",
+    "@aws-sdk/client-sns": "^3.388.0",
+    "@aws-sdk/client-sqs": "^3.388.0",
+    "@aws-sdk/client-ssm": "^3.388.0",
+    "@aws-sdk/lib-dynamodb": "^3.388.0"
+  },
+  "devDependencies": {
+    "@aws-sdk/util-stream-node": "^3.374.0",
+    "@tsconfig/node18": "^1.0.1",
+    "@types/aws-sdk": "^2.7.0",
+    "@types/jest": "^29.4.0",
+    "@types/node": "^18.14.2",
+    "@typescript-eslint/eslint-plugin": "^5.25.0",
+    "@typescript-eslint/parser": "^5.25.0",
+    "aws-sdk-client-mock": "^3.0.0",
+    "esbuild-jest": "^0.4.0",
+    "eslint": "^8.11.0",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-plugin-import": "^2.25.4",
+    "eslint-plugin-json": "^3.1.0",
+    "eslint-plugin-markdown": "^3.0.0",
+    "husky": "^8.0.1",
+    "jest": "^29.4.3",
+    "jest-cli": "^29.4.3",
+    "jest-sonar-reporter": "^2.0.0",
+    "lint-staged": "^13.1.2",
+    "prettier": "^2.6.2",
+    "prettier-plugin-sh": "^0.12.8",
+    "rimraf": "^5.0.0",
+    "typedoc": "^0.24.4",
+    "typedoc-plugin-markdown": "^3.14.0",
+    "typescript": "^5.0.4"
+  },
+  "jestSonar": {
+    "reportPath": ".sonar",
+    "reportFile": "test-report.xml"
+  }
+
+  ,"publishConfig": {
+    "access": "public"
+  }
+}

package/sonar-project.properties

@@ -0,0 +1,8 @@
+sonar.projectKey=tomassaboldev_aws-services_bb5f4f68-64f8-4726-bdd4-579ceadf172d
+sonar.sources=src
+sonar.tests=test
+sonar.exclusions=src/logger.ts
+sonar.scm.provider=git
+sonar.qualitygate.wait=true
+sonar.javascript.lcov.reportPaths=.coverage/lcov.info
+sonar.testExecutionReportPaths=.sonar/test-report.xml

package/src/appconfig.ts

@@ -0,0 +1,20 @@
+import {
+  AppConfigClient,
+  GetApplicationCommand,
+} from "@aws-sdk/client-appconfig"
+import { logger } from "./logger"
+
+export const appConfigClient = new AppConfigClient({})
+
+export const getApplication = async (applicationId: string) => {
+  try {
+    return await appConfigClient.send(
+      new GetApplicationCommand({
+        ApplicationId: applicationId,
+      })
+    )
+  } catch (error) {
+    logger.error("getApplication", { error, applicationId })
+    throw error
+  }
+}

package/src/dynamodb.mock.ts

@@ -0,0 +1,10 @@
+export const mockDynamodbService = {
+  client: {
+    send: jest.fn(),
+  },
+  documentClient: {
+    send: jest.fn(),
+  },
+}
+
+jest.mock("@tomassabol/aws-services/dynamodb", () => mockDynamodbService)

package/src/dynamodb.ts

@@ -0,0 +1,7 @@
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb"
+import { DynamoDBDocumentClient } from "@aws-sdk/lib-dynamodb"
+
+export const client: DynamoDBClient = new DynamoDBClient({})
+
+export const documentClient: DynamoDBDocumentClient =
+  DynamoDBDocumentClient.from(client)

package/src/eventbridge.mock.ts

@@ -0,0 +1,5 @@
+export const mockEventbridgeService = {
+  sendEvent: jest.fn(),
+}
+
+jest.mock("@tomassabol/aws-services/eventbridge", () => mockEventbridgeService)

package/src/eventbridge.ts

@@ -0,0 +1,47 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import {
+  EventBridgeClient,
+  PutEventsCommand,
+} from "@aws-sdk/client-eventbridge"
+import { logger } from "./logger"
+
+export const client = new EventBridgeClient({})
+
+export async function sendEvent(params: {
+  source: string
+  eventBusName: string
+  eventType: string
+  event: any
+}) {
+  const { eventBusName, eventType, event, source } = params
+
+  const input = {
+    Entries: [
+      {
+        EventBusName: eventBusName,
+        Source: source,
+        DetailType: eventType,
+        Detail: JSON.stringify(event),
+      },
+    ],
+  }
+
+  const command = new PutEventsCommand(input)
+
+  try {
+    const result = await client.send(command)
+
+    /* Check if there are any failed events */
+    if (result.FailedEntryCount) {
+      const errorDetail = result.Entries?.length
+        ? `${result.Entries[0].ErrorCode}: ${result.Entries[0].ErrorMessage}}`
+        : "unknown"
+      throw new Error(`PutEventsCommand error ${errorDetail}`)
+    }
+
+    logger.debug("sendEvent success", { input, result })
+  } catch (error) {
+    logger.error("sendEvent error", { input, error })
+    throw error
+  }
+}

package/src/logger.ts

@@ -0,0 +1,14 @@
+import { Logger } from "@aws-lambda-powertools/logger"
+
+const noLogger = {
+  log: () => undefined,
+  debug: () => undefined,
+  info: () => undefined,
+  error: () => undefined,
+  warn: () => undefined,
+} as typeof console
+
+export const logger =
+  process.env.JEST_WORKER_ID === undefined || process.env.TEST_LOGGER
+    ? new Logger({ logLevel: "DEBUG" })
+    : noLogger

package/src/s3.ts

@@ -0,0 +1,56 @@
+import { S3, PutObjectCommandOutput } from "@aws-sdk/client-s3"
+import { logger } from "./logger"
+
+export const client = new S3({})
+
+export async function putObjectToS3(params: {
+  bucket: string
+  key: string
+  body: string | Uint8Array | Buffer
+  contentEncoding: string
+  contentType: string
+}): Promise<PutObjectCommandOutput> {
+  const { bucket, key, body, contentEncoding, contentType } = params
+
+  try {
+    return await client.putObject({
+      Bucket: bucket,
+      Key: key,
+      Body: body,
+      ContentEncoding: contentEncoding,
+      ContentType: contentType,
+    })
+  } catch (error) {
+    logger.error("putObjectToS3", {
+      error,
+      params: { bucket, key, contentEncoding, contentType },
+    })
+    throw error
+  }
+}
+
+export async function getObjectFromS3(params: {
+  bucket: string
+  key: string
+}): Promise<Uint8Array> {
+  try {
+    const { bucket, key } = params
+
+    const result = await client.getObject({
+      Bucket: bucket,
+      Key: key,
+    })
+
+    const body = result.Body
+
+    if (body === undefined) {
+      logger.error("Body not found", { params })
+      throw new Error("Body not found")
+    }
+
+    return await body.transformToByteArray()
+  } catch (error) {
+    logger.error("getObjectFromS3", { error, params })
+    throw error
+  }
+}

package/src/secrets-manager.mock.ts

@@ -0,0 +1,9 @@
+export const mockSecretsManagerService = {
+  getSecret: jest.fn(),
+  getSecretAsObject: jest.fn(),
+}
+
+jest.mock(
+  "@tomassabol/aws-services/secrets-manager",
+  () => mockSecretsManagerService
+)

package/src/secrets-manager.ts

@@ -0,0 +1,37 @@
+import {
+  SecretsManagerClient,
+  GetSecretValueCommand,
+} from "@aws-sdk/client-secrets-manager"
+import assert from "assert"
+import { logger } from "./logger"
+
+export const client = new SecretsManagerClient({})
+
+export async function getSecret(secretName: string): Promise<string> {
+  try {
+    const response = await client.send(
+      new GetSecretValueCommand({
+        SecretId: secretName,
+      })
+    )
+    const value = response.SecretString
+    assert(value, "SecretString value not found")
+    return value
+  } catch (error) {
+    logger.error("getSecret", { error, secretName })
+    // For a list of exceptions thrown, see
+    // https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html
+    throw error
+  }
+}
+
+export async function getSecretAsObject<T = unknown>(
+  secretName: string
+): Promise<T> {
+  const value = await getSecret(secretName)
+  try {
+    return JSON.parse(value)
+  } catch (error) {
+    throw Error(`Cannot parse secret ${secretName}. Expected JSON.`)
+  }
+}

package/src/sns.ts

@@ -0,0 +1,24 @@
+import { SNSClient, PublishCommand } from "@aws-sdk/client-sns"
+import { logger } from "./logger"
+
+export const snsClient = new SNSClient({})
+
+export const publishMessageToSNS = async (params: {
+  topicArn: string
+  message: string
+  options?: object
+}) => {
+  try {
+    const { topicArn, message, options } = params
+    return await snsClient.send(
+      new PublishCommand({
+        TopicArn: topicArn,
+        Message: message,
+        ...options,
+      })
+    )
+  } catch (error) {
+    logger.error("publishMessageToSNS", { error, params })
+    throw error
+  }
+}

package/src/sqs.mock.ts

@@ -0,0 +1,5 @@
+export const mockSqsService = {
+  sendSqsMessage: jest.fn(),
+}
+
+jest.mock("@tomassabol/aws-services/sqs", () => mockSqsService)

package/src/sqs.ts

@@ -0,0 +1,32 @@
+import {
+  SQSClient,
+  SendMessageCommand,
+  SendMessageCommandInput,
+} from "@aws-sdk/client-sqs"
+import { logger } from "./logger"
+
+export const client = new SQSClient({})
+
+export async function sendSqsMessage(params: {
+  queueUrl: string
+  message: string | object
+}): Promise<string | undefined> {
+  const { queueUrl, message } = params
+
+  try {
+    const body = typeof message === "object" ? JSON.stringify(message) : message
+
+    const input: SendMessageCommandInput = {
+      QueueUrl: queueUrl,
+      MessageBody: body,
+    }
+
+    const command = new SendMessageCommand(input)
+
+    const response = await client.send(command)
+    return response.MessageId
+  } catch (error) {
+    logger.error("sendSqsMessage", { error, params })
+    throw error
+  }
+}

package/src/ssm.mock.ts

@@ -0,0 +1,5 @@
+export const mockSsmService = {
+  getSsmParameters: jest.fn(),
+}
+
+jest.mock("@tomassabol/aws-services/ssm", () => mockSsmService)

package/src/ssm.ts

@@ -0,0 +1,70 @@
+import { SSMClient, GetParametersCommand } from "@aws-sdk/client-ssm"
+import assert = require("assert")
+
+export const client = new SSMClient({})
+
+export type SSMParameters = {
+  [name: string]: string
+}
+
+/**
+ * Get a list of parameters from SSM Parameter Store
+ *
+ * @example
+ * ```typescript
+ * const params = await getSsmParameters({
+ *   first: "/my-params/first",
+ *   second: "/my-params/second",
+ * })
+ *
+ * // params = { first: "value1", second: "value2" }
+ * ```
+ */
+
+export async function getSsmParameters<T extends SSMParameters>(
+  parameters: T
+): Promise<T> {
+  /*
+   * Fetch parameters from SSM
+   */
+
+  const command = new GetParametersCommand({
+    Names: Object.values(parameters),
+  })
+
+  const output = await client.send(command)
+
+  /*
+   * Map returned parameters to result object
+   */
+
+  const result: Record<string, string> = {}
+  output.Parameters?.forEach((outputParam) => {
+    assert(
+      typeof outputParam.Value === "string",
+      `Received invalid value of SSM parameter ${outputParam.Name}`
+    )
+    const entry = Object.entries(parameters).find(
+      ([_key, value]) => value === outputParam.Name
+    )
+    assert(entry, `Received invalid SSM parameter ${outputParam.Name}`)
+    const [key] = entry
+    result[key] = outputParam.Value
+  })
+
+  /*
+   * Check that all parameters were received
+   */
+
+  const notFoundParams = Object.keys(parameters).filter(
+    (key) => false === Object.hasOwn(result, key)
+  )
+
+  if (notFoundParams.length > 0) {
+    throw new Error(
+      `Cannot obtain SSM parameters: ${notFoundParams.join(", ")}`
+    )
+  }
+
+  return result as T
+}

package/test/appconfig.test.ts

@@ -0,0 +1,45 @@
+import { GetApplicationCommand } from "@aws-sdk/client-appconfig"
+import { getApplication, appConfigClient } from "../src/appconfig"
+
+jest.mock("@aws-sdk/client-appconfig", () => {
+  return {
+    AppConfigClient: jest.fn().mockImplementation(() => {
+      return { send: jest.fn() }
+    }),
+    GetApplicationCommand: jest.fn(),
+  }
+})
+
+describe("AppConfig", () => {
+  let getApplicationCommandMock: jest.Mock
+
+  beforeEach(() => {
+    getApplicationCommandMock = GetApplicationCommand as unknown as jest.Mock
+  })
+
+  afterEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it("should call AppConfig.getApplication with correct parameters", async () => {
+    const applicationId = "test-app"
+
+    await getApplication(applicationId)
+
+    expect(appConfigClient.send).toHaveBeenCalledWith(
+      expect.any(getApplicationCommandMock)
+    )
+    expect(getApplicationCommandMock).toHaveBeenCalledWith({
+      ApplicationId: applicationId,
+    })
+  })
+
+  it("should throw an error if getting application from AppConfig fails", async () => {
+    const applicationId = "test-app"
+    const error = new Error("Get application failed")
+
+    ;(appConfigClient.send as jest.Mock).mockRejectedValueOnce(error)
+
+    await expect(getApplication(applicationId)).rejects.toThrow(error)
+  })
+})

package/test/dynamodb.test.ts

@@ -0,0 +1,13 @@
+import { client, documentClient } from "../src/dynamodb"
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb"
+import { DynamoDBDocumentClient } from "@aws-sdk/lib-dynamodb"
+
+describe("dynamodb", () => {
+  it("should be instance of DynamoDBClient", () => {
+    expect(client).toBeInstanceOf(DynamoDBClient)
+  })
+
+  it("should be instance of DynamoDBDocumentClient", () => {
+    expect(documentClient).toBeInstanceOf(DynamoDBDocumentClient)
+  })
+})

package/test/eventbridge.test.ts

@@ -0,0 +1,35 @@
+import { mockClient } from "aws-sdk-client-mock"
+import { PutEventsCommand } from "@aws-sdk/client-eventbridge"
+import { client, sendEvent } from "../src/eventbridge"
+
+const eventBridgeMock = mockClient(client)
+
+describe("eventbridge", () => {
+  describe("sendEvent", () => {
+    test("should send event to event bus", async () => {
+      eventBridgeMock.on(PutEventsCommand).resolves({})
+
+      const params = {
+        source: "source",
+        eventBusName: "event-bus-name",
+        eventType: "event-type",
+        event: { foo: "bar" },
+      }
+
+      await expect(sendEvent(params)).resolves.toBe(undefined)
+    })
+
+    test("should fail", async () => {
+      eventBridgeMock.on(PutEventsCommand).rejects(new Error("fail"))
+
+      const params = {
+        source: "source",
+        eventBusName: "event-bus-name",
+        eventType: "event-type",
+        event: { foo: "bar" },
+      }
+
+      await expect(sendEvent(params)).rejects.toThrowError("fail")
+    })
+  })
+})

package/test/s3.test.ts

@@ -0,0 +1,78 @@
+/* eslint-disable  @typescript-eslint/no-explicit-any */
+import { mockClient } from "aws-sdk-client-mock"
+import { GetObjectCommand, PutObjectCommand } from "@aws-sdk/client-s3"
+import { Readable } from "stream"
+import { sdkStreamMixin } from "@aws-sdk/util-stream-node"
+import { client, getObjectFromS3, putObjectToS3 } from "../src/s3"
+
+const s3Mock = mockClient(client)
+
+describe("S3", () => {
+  describe("putObjectToS3()", () => {
+    test("should put object to S3", async () => {
+      s3Mock.on(PutObjectCommand).resolves({
+        ETag: "etag",
+      })
+
+      const params = {
+        bucket: "bucket",
+        key: "key",
+        body: "body",
+        contentEncoding: "content-encoding",
+        contentType: "content-type",
+      }
+
+      await expect(putObjectToS3(params)).resolves.toEqual({ ETag: "etag" })
+    })
+
+    test("should fail when put object to S3 fails", async () => {
+      s3Mock.on(PutObjectCommand).rejects(new Error("fail"))
+
+      await expect(putObjectToS3({} as any)).rejects.toThrowError("fail")
+    })
+  })
+
+  describe("getObjectFromS3()", () => {
+    test("should get object from S3", async () => {
+      s3Mock.on(GetObjectCommand).resolves({
+        ETag: "etag",
+        Body: sdkStreamMixin(Readable.from("object")),
+      })
+
+      const params = {
+        bucket: "bucket",
+        key: "key",
+      }
+
+      const data = (await getObjectFromS3(params)) as any
+
+      expect(data).toMatchInlineSnapshot(`
+        Uint8Array [
+          111,
+          98,
+          106,
+          101,
+          99,
+          116,
+        ]
+      `)
+    })
+
+    test("should fail when get object body is undefined", async () => {
+      s3Mock.on(GetObjectCommand).resolves({
+        ETag: "etag",
+        Body: undefined,
+      })
+
+      await expect(getObjectFromS3({} as any)).rejects.toThrowError(
+        "Body not found"
+      )
+    })
+
+    test("should fail when get object from S3 fails", async () => {
+      s3Mock.on(GetObjectCommand).rejects(new Error("fail"))
+
+      await expect(getObjectFromS3({} as any)).rejects.toThrowError("fail")
+    })
+  })
+})

package/test/secrets-manager.test.ts

@@ -0,0 +1,55 @@
+import { mockClient } from "aws-sdk-client-mock"
+import { GetSecretValueCommand } from "@aws-sdk/client-secrets-manager"
+import { client, getSecret, getSecretAsObject } from "../src/secrets-manager"
+
+const secretsManagerMock = mockClient(client)
+
+describe("secrets-manager", () => {
+  describe("getSecret()", () => {
+    test("should retrieve secret string", async () => {
+      secretsManagerMock.on(GetSecretValueCommand).resolves({
+        SecretString: "secret-string",
+      })
+
+      await expect(getSecret("secret-name")).resolves.toBe("secret-string")
+    })
+
+    test("should fail when string empty", async () => {
+      secretsManagerMock.on(GetSecretValueCommand).resolves({
+        SecretString: "",
+      })
+
+      await expect(getSecret("secret-name")).rejects.toThrow(
+        "SecretString value not found"
+      )
+    })
+
+    test("should fail", async () => {
+      secretsManagerMock.on(GetSecretValueCommand).rejects(new Error("fail"))
+
+      await expect(getSecret("secret-name")).rejects.toThrowError("fail")
+    })
+  })
+
+  describe("getSecretAsObject()", () => {
+    test("should return secret object", async () => {
+      secretsManagerMock.on(GetSecretValueCommand).resolves({
+        SecretString: JSON.stringify({ foo: "bar" }),
+      })
+
+      await expect(getSecretAsObject("secret-name")).resolves.toEqual({
+        foo: "bar",
+      })
+    })
+
+    test("should fail when invalid object", async () => {
+      secretsManagerMock.on(GetSecretValueCommand).resolves({
+        SecretString: "invalid-object",
+      })
+
+      await expect(getSecretAsObject("secret-name")).rejects.toThrowError(
+        "Cannot parse secret secret-name. Expected JSON."
+      )
+    })
+  })
+})

package/test/sns.test.ts

@@ -0,0 +1,59 @@
+import { SNSClient, PublishCommand } from "@aws-sdk/client-sns"
+import { publishMessageToSNS, snsClient } from "../src/sns"
+
+jest.mock("@aws-sdk/client-sns", () => {
+  return {
+    SNSClient: jest.fn(() => {
+      return {
+        send: jest.fn(),
+      }
+    }),
+    PublishCommand: jest.fn(),
+  }
+})
+
+describe("SNS", () => {
+  beforeEach(() => {
+    ;(SNSClient as jest.Mock).mockClear()
+    ;(PublishCommand as unknown as jest.Mock).mockClear()
+    ;(snsClient.send as jest.Mock).mockClear()
+  })
+
+  it("should create instance of SNSClient", () => {
+    expect(snsClient).toBeDefined()
+  })
+
+  it("should call publishSNSMessage successfully", async () => {
+    const sendMock = jest.fn()
+    ;(snsClient.send as jest.Mock) = sendMock
+
+    const params = {
+      topicArn: "arn:aws:sns:eu-central-1:123456789012:MyTopic",
+      message: "Test message",
+    }
+
+    await publishMessageToSNS(params)
+    expect(sendMock).toBeCalledTimes(1)
+    expect(PublishCommand).toHaveBeenCalledWith({
+      TopicArn: params.topicArn,
+      Message: params.message,
+    })
+  })
+
+  it("should throw an error if publishSNSMessage fails", async () => {
+    const sendMock = jest
+      .fn()
+      .mockRejectedValue(new Error("Failed to send message"))
+    ;(snsClient.send as jest.Mock) = sendMock
+
+    const params = {
+      topicArn: "arn:aws:sns:euj-central-1:123456789012:MyTopic",
+      message: "Test message",
+    }
+
+    await expect(publishMessageToSNS(params)).rejects.toThrow(
+      "Failed to send message"
+    )
+    expect(sendMock).toBeCalledTimes(1)
+  })
+})

package/test/sqs.test.ts

@@ -0,0 +1,46 @@
+import { mockClient } from "aws-sdk-client-mock"
+import { SendMessageCommand } from "@aws-sdk/client-sqs"
+import { client, sendSqsMessage } from "../src/sqs"
+
+const sqsMock = mockClient(client)
+
+describe("sqs", () => {
+  describe("sendSqsMessage()", () => {
+    test("should send string as message to SQS", async () => {
+      sqsMock.on(SendMessageCommand).resolves({
+        MessageId: "message-id",
+      })
+
+      const params = {
+        queueUrl: "queue-url",
+        message: "message",
+      }
+
+      await expect(sendSqsMessage(params)).resolves.toBe("message-id")
+    })
+
+    test("should send stringified object as message to SQS", async () => {
+      sqsMock.on(SendMessageCommand).resolves({
+        MessageId: "message-id",
+      })
+
+      const params = {
+        queueUrl: "queue-url",
+        message: { foo: "bar" },
+      }
+
+      await expect(sendSqsMessage(params)).resolves.toBe("message-id")
+    })
+
+    test("should fail", async () => {
+      sqsMock.on(SendMessageCommand).rejects(new Error("fail"))
+
+      const params = {
+        queueUrl: "queue-url",
+        message: "message",
+      }
+
+      await expect(sendSqsMessage(params)).rejects.toThrowError("fail")
+    })
+  })
+})

package/test/ssm.test.ts

@@ -0,0 +1,85 @@
+/* eslint-disable  @typescript-eslint/no-explicit-any */
+import { mockClient } from "aws-sdk-client-mock"
+import { GetParametersCommand } from "@aws-sdk/client-ssm"
+import { client, getSsmParameters } from "../src/ssm"
+
+const ssmMock = mockClient(client)
+
+describe("ssm", () => {
+  describe("getSsmParameters()", () => {
+    test("should return paramaters", async () => {
+      ssmMock.on(GetParametersCommand).resolves({
+        Parameters: [
+          { Name: "/my-params/foo", Value: "bar" },
+          { Name: "/my-params/baz", Value: "qux" },
+        ],
+      })
+
+      const params = {
+        foo: "/my-params/foo",
+        baz: "/my-params/baz",
+      }
+
+      await expect(getSsmParameters(params)).resolves.toEqual({
+        foo: "bar",
+        baz: "qux",
+      })
+    })
+
+    test("should fail when SSM parameter name is not string", async () => {
+      ssmMock.on(GetParametersCommand).resolves({
+        Parameters: [{ Name: 42 as any, Value: "bar" }],
+      })
+
+      const params = {
+        foo: "/my-params/foo",
+      }
+
+      await expect(getSsmParameters(params)).rejects.toThrow(
+        "Received invalid SSM parameter 42"
+      )
+    })
+
+    test("should fail when SSM parameter does not contain Parameters", async () => {
+      ssmMock.on(GetParametersCommand).resolves({})
+
+      const params = {
+        foo: "/my-params/foo",
+      }
+
+      await expect(getSsmParameters(params)).rejects.toThrow(
+        "Cannot obtain SSM parameters: foo"
+      )
+    })
+
+    test("should fail when SSM parameter value is not string", async () => {
+      ssmMock.on(GetParametersCommand).resolves({
+        Parameters: [{ Name: "/my-params/foo", Value: 42 as any }],
+      })
+
+      const params = {
+        foo: "/my-params/foo",
+      }
+
+      await expect(getSsmParameters(params)).rejects.toThrow(
+        "Received invalid value of SSM parameter /my-params/foo"
+      )
+    })
+
+    test("should fail when not all parameters are found", async () => {
+      ssmMock.on(GetParametersCommand).resolves({
+        Parameters: [{ Name: "/my-params/foo", Value: "bar" }],
+      })
+
+      const params = {
+        foo: "/my-params/foo",
+        baz: "/my-params/baz",
+        quux: "/my-params/quux",
+      }
+
+      await expect(getSsmParameters(params)).rejects.toThrow(
+        "Cannot obtain SSM parameters: baz, quux"
+      )
+    })
+  })
+})

package/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig",
+  "include": ["src"]
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "@tsconfig/node18",
+  "compilerOptions": {
+    "strict": true,
+    "declaration": true,
+    "outDir": "dist"
+  },
+  "include": ["src", "test"]
+}

package/typedoc.json

@@ -0,0 +1,4 @@
+{
+  "entryPoints": ["src/index.ts"],
+  "readme": "none"
+}