codeweaver 3.1.3 → 4.0.1

package/README.md

@@ -1,21 +1,27 @@
-# A lightweight framework built on top of Express and TypeScript
+# Codeweaver
 
 ## Overview
 
-**Codeweaver** is an microframework built with `Express`, `TypeScript`, and `Zod` (v4), seamlessly integrated with `Swagger` for comprehensive API documentation. Its modular architecture for routers promotes scalability and organized development, making it easy to expand and maintain. Routers are automatically discovered and wired up through a conventional folder structure, simplifying project organization and reducing boilerplate. Routers can be nested, allowing you to compose complex route trees by placing sub-routers inside parent router folders. It also uses `utils-decorators`, a collection of middleware utilities (throttling, caching, and error handling) designed to strengthen application resilience.
+**Codeweaver** is a lightweight framework and boilerplate built on top of `Express` and `TypeScript`. Its modular architecture for routers promotes scalability and organized development, making it easy to expand and maintain. Routers are automatically discovered and wired up through a conventional folder structure, simplifying project organization and reducing boilerplate. Routers can be nested, allowing you to compose complex route trees by placing sub-routers inside parent router folders.
 
 ## Features and Technologies Used
 
-- **Node.js**
-- **Express**: A lightweight web framework for building server-side applications in Node.js.
-- **TypeScript**: Adds strong typing for enhanced development experience and reduced runtime errors.
 - **Modular Router Structure**: Automates importing and mounting routers, ensuring a clean separation of endpoints and logic for easier scalability.
-- **Dependency resolver**: A simple dependency resolver that uses a lightweight container to manage and inject dependencies at runtime.
 - **Swagger Integration**: Automatically generates interactive API documentation, facilitating easier understanding of available endpoints for developers and consumers.
-- **Async Handlers**: Utilizes async/await syntax for cleaner, more maintainable asynchronous code without callback nesting.
-- **Zod**: Implements schema validation for input data.
-- **Utils-decorators**: A collection of middleware utilities utils-decorators (throttling, caching, and error handling) designed to strengthen application resilience.
+- **Dependency resolver**: A simple dependency resolver that uses a lightweight container to manage and inject dependencies at runtime.
 - **Logger**: A Winston-based logger (with LogForm) that provides scalable, leveled logging, structured JSON output, and pluggable transports (console and file)
+- **AWS integrations**: API Gateway, Lambda, S3, SNS, SES, SQS, and DynamoDB adapters
+- **IO**: Reading, writing JSON and YAML
+- **Messaging**: Kafka, RabbitMQ, BullMQ adapters
+- **Parallelism**: Channel, Worker-pool
+- **Decorators and Middlewares**:
+  - Caching: Memory and Redis backends
+  - Rate limiting, Retry, Debounce, Timeout
+  - Guard (authentication/authorization)
+  - Before/After hooks
+  - Memoization
+  - Logging: Winston-based, LogForm, structured JSON, pluggable transports
+  - Error handling: Centralized error types and handlers
 
 Here's a revised Installation section that explicitly supports pnpm in addition to npm. I kept the formatting and steps intact, adding clear pnpm equivalents.
 
@@ -47,6 +53,14 @@ To get started with the project, follow these steps:
 
 3. **Run the application**:
 
+   Using pnpm:
+
+   ```bash
+   pnpm start
+   ```
+
+   Using npm:
+
    ```bash
    npm start
    ```
@@ -55,6 +69,15 @@ To get started with the project, follow these steps:
 
 5. **Build**: Compile the TypeScript files for the production environment:
 
+   Using pnpm:
+
+   ```bash
+   pnpm run build
+   pnpm run serve
+   ```
+
+   Using npm:
+
    ```bash
    npm run build
    npm run serve
@@ -101,7 +124,7 @@ Example of a basic router:
 import { Router, Request, Response } from "express";
 import asyncHandler from "express-async-handler";
 import UserController from "./user.controller";
-import { resolve } from "@/utilities/container";
+import { resolve } from "@/core/container";
 
 const router = Router();
 const userController = resolve(UserController);
@@ -211,28 +234,23 @@ Here’s a brief breakdown of key components used in the `UserController`:
 
 ```typescript
 import { UserCreationDto, UserDto, ZodUserDto } from "./dto/user.dto";
-import { memoizeAsync, onError, rateLimit, timeout } from "utils-decorators";
-import { ResponseError } from "@/utilities/error-handling";
-import { convert, stringToInteger } from "@/utilities/conversion";
+import { ResponseError } from "@/core/error";
+import { convert, stringToInteger } from "@/core/helpers";
 import { config } from "@/config";
 import { users } from "@/db";
 import { User, ZodUser } from "@/entities/user.entity";
-import { MapAsyncCache } from "@/utilities/cache/memory-cache";
-import { Injectable } from "@/utilities/container";
-import { parallelMap } from "@/utilities/parallel/parallel";
+import { Invalidate, MapAsyncCache, Memoize } from "@/core/cache";
+import { Injectable } from "@/core/container";
+import { parallelMap } from "@/core/parallel";
+import { ErrorHandler, LogMethod, Timeout } from "@/core/middlewares";
+import { RateLimit } from "@/core/rate-limit";
 
-function exceedHandler() {
-  const message = "Too much call in allowed window";
-  throw new ResponseError(message, 429);
-}
-
-function invalidInputHandler(e: ResponseError) {
+async function invalidInputHandler(e: ResponseError) {
   const message = "Invalid input";
   throw new ResponseError(message, 400, e?.message);
 }
 
 const usersCache = new MapAsyncCache<UserDto[]>(config.cacheSize);
-const userCache = new MapAsyncCache<UserDto>(config.cacheSize);
 
 @Injectable()
 /**
@@ -243,9 +261,7 @@ const userCache = new MapAsyncCache<UserDto>(config.cacheSize);
 export default class UserController {
   // constructor(private readonly userService: UserService) { }
 
-  @onError({
-    func: invalidInputHandler,
-  })
+  @ErrorHandler(invalidInputHandler)
   /**
    * Validates a string ID and converts it to a number.
    *
@@ -256,9 +272,7 @@ export default class UserController {
     return stringToInteger(id);
   }
 
-  @onError({
-    func: invalidInputHandler,
-  })
+  @ErrorHandler(invalidInputHandler)
   /**
    * Validates and creates a new User from the given DTO.
    *
@@ -269,11 +283,8 @@ export default class UserController {
     return await convert(user, ZodUser);
   }
 
-  @rateLimit({
-    timeSpanMs: config.rateLimitTimeSpan,
-    allowedCalls: config.rateLimitAllowedCalls,
-    exceedHandler,
-  })
+  @Invalidate(usersCache)
+  @RateLimit(config.rateLimitTimeSpan, config.rateLimitAllowedCalls)
   /**
    * Create a new user
    * @param {User} user - User creation data validated by Zod schema
@@ -283,42 +294,26 @@ export default class UserController {
    */
   public async create(user: User): Promise<void> {
     users.push(user);
-    await usersCache.delete("key");
   }
 
-  @memoizeAsync({
-    cache: usersCache,
-    keyResolver: () => "key",
-    expirationTimeMs: config.memoizeTime,
-  })
-  @timeout(config.timeout)
-  @rateLimit({
-    timeSpanMs: config.rateLimitTimeSpan,
-    allowedCalls: config.rateLimitAllowedCalls,
-    exceedHandler,
-  })
+  @Memoize(usersCache)
+  @Timeout(config.timeout)
+  @RateLimit(config.rateLimitTimeSpan, config.rateLimitAllowedCalls)
   /**
    * Get all users
    * @returns {Promise<UserDto[]>} List of users with hidden password fields
    * @throws {ResponseError} 500 - When rate limit exceeded
    */
-  public async getAll(): Promise<UserDto[]> {
-    return await parallelMap(
-      users,
-      async (user) => await convert(user, ZodUserDto)
+  public async getAll(signal?: AbortSignal): Promise<(UserDto | undefined)[]> {
+    return await parallelMap(users, async (user) =>
+      signal?.aborted == false
+        ? await convert<User, UserDto>(user!, ZodUserDto)
+        : null
     );
   }
 
-  @memoizeAsync({
-    cache: userCache,
-    keyResolver: (id: number) => id.toString(),
-    expirationTimeMs: config.memoizeTime,
-  })
-  @rateLimit({
-    timeSpanMs: config.rateLimitTimeSpan,
-    allowedCalls: config.rateLimitAllowedCalls,
-    exceedHandler,
-  })
+  @Memoize(usersCache)
+  @RateLimit(config.rateLimitTimeSpan, config.rateLimitAllowedCalls)
   /**
    * Get user by ID
    * @param {number} id - User ID as string
@@ -329,7 +324,7 @@ export default class UserController {
   public async get(id: number): Promise<UserDto> {
     const user = users.find((user) => user.id === id);
     if (user == null) {
-      throw new ResponseError("Product not found");
+      throw new ResponseError("User not found");
     }
     return convert(user, ZodUserDto);
   }
@@ -338,18 +333,6 @@ export default class UserController {
 
 This structure not only supports effective code organization but also ensures that each part of the application is working towards the same goal: a scalable, maintainable, and robust API.
 
-### Async Handlers
-
-To maintain cleaner code and improve error handling, the app suggests the `express-async-handler` package that automatically catches exceptions inside of async express routes and passing them to the express error handlers. This allows you to focus on writing the business logic without worrying about try/catch blocks.
-
-### API Documentation
-
-Once the application is running, visit the Swagger UI at http://localhost:3000/api-docs. This automatically generated documentation will provide you with all available routes along with details on request parameters, response structures, and possible error codes.
-
-### Decorators
-
-To prevent abuse of your API, you can utilize throttling, caching, and error handling decorators from the `utils-decorators` package. This package provides decorators that can be applied directly to your service and controller classes.
-
 ### Contributing
 
 Contributions are welcome! If you have suggestions for improvements or new features, feel free to create an issue or submit a pull request.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeweaver",
-  "version": "3.1.3",
+  "version": "4.0.1",
   "main": "src/main.ts",
   "bin": {
     "codeweaver": "command.js"
@@ -26,13 +26,30 @@
   "license": "MIT",
   "description": "An unopinionated microframework built with Express, TypeScript, Zod, Swagger",
   "dependencies": {
+    "@aws-sdk/client-api-gateway": "^3.943.0",
+    "@aws-sdk/client-dynamodb": "^3.943.0",
+    "@aws-sdk/client-lambda": "^3.942.0",
+    "@aws-sdk/client-s3": "^3.940.0",
+    "@aws-sdk/client-sesv2": "^3.943.0",
+    "@aws-sdk/client-sns": "^3.943.0",
+    "@aws-sdk/client-sqs": "^3.943.0",
+    "@aws-sdk/lib-dynamodb": "^3.943.0",
+    "@aws-sdk/s3-request-presigner": "^3.940.0",
+    "amqplib": "^0.10.9",
+    "bullmq": "^5.65.1",
     "cors": "^2.8.5",
     "dotenv": "^17.2.3",
+    "drizzle-orm": "^0.45.0",
     "express": "^5.1.0",
     "express-async-handler": "^1.2.0",
     "express-winston": "^4.2.0",
+    "helmet": "^8.1.0",
     "ioredis": "^5.8.2",
+    "js-yaml": "^4.1.1",
+    "jsonwebtoken": "^9.0.2",
+    "kafkajs": "^2.2.4",
     "logform": "^2.7.0",
+    "passport": "^0.7.0",
     "reflect-metadata": "^0.2.2",
     "swagger-jsdoc": "^3.7.0",
     "utils-decorators": "^2.10.0",
@@ -41,11 +58,16 @@
     "zod": "^4.0.14"
   },
   "devDependencies": {
+    "@aws-sdk/types": "^3.936.0",
     "@types/cors": "^2.8.19",
     "@types/express": "^5.0.3",
+    "@types/js-yaml": "^4.0.9",
+    "@types/jsonwebtoken": "^9.0.10",
     "@types/node": "^24.1.0",
+    "@types/passport": "^1.0.17",
     "copyfiles": "^2.4.1",
     "cross-env": "^10.0.0",
+    "drizzle-kit": "^0.31.8",
     "nodemon": "^3.1.10",
     "swagger-ui-express": "^5.0.1",
     "ts-node": "^10.9.2",

package/src/config.ts

@@ -7,10 +7,10 @@ import {
   port,
   cacheSize,
   http,
-} from "./constants";
+  debounceTimeSpan,
+} from "@/constants";
 import { SwaggerOptions } from "./swagger-options";
-import { stringToBoolean } from "./utilities/conversion";
-import { logger } from "./utilities/logger/logger.config";
+import { stringToBoolean } from "@/core/helpers/conversion";
 
 /**
  * Main application configuration
@@ -20,16 +20,18 @@ import { logger } from "./utilities/logger/logger.config";
  * @property {SwaggerOptions} swaggerOptions - Swagger configuration
  */
 interface Config {
-  devMode: boolean;
-  http: string;
-  port: number;
-  swagger: boolean;
-  swaggerOptions: SwaggerOptions;
-  timeout: number;
-  rateLimitTimeSpan: number;
-  rateLimitAllowedCalls: number;
-  memoizeTime: number;
-  cacheSize: number;
+  readonly devMode: boolean;
+  readonly http: string;
+  readonly port: number;
+  readonly swagger: boolean;
+  readonly swaggerOptions: SwaggerOptions;
+  readonly timeout: number;
+  readonly rateLimitTimeSpan: number;
+  readonly rateLimitAllowedCalls: number;
+  readonly memoizeTime: number;
+  readonly cacheSize: number;
+  readonly jwtSecretKey: string;
+  readonly debounceTimeSpan: number;
 }
 
 export const config: Config = {
@@ -65,6 +67,6 @@ export const config: Config = {
     Number(process.env.RATE_LIMIT_ALLOWED_CALLS) || rateLimitAllowedCalls,
   memoizeTime: Number(process.env.MEMOIZE_TIME) || memoizeTime,
   cacheSize: Number(process.env.CACHE_SIZE) || cacheSize,
+  jwtSecretKey: process.env.JWT_SECRET_KEY!,
+  debounceTimeSpan: Number(process.env.DEBOUNCE_TIME_SPAN) || debounceTimeSpan,
 };
-
-export const container = { logger };

package/src/constants.ts

@@ -10,3 +10,4 @@ export const swaggerPath = "/api-docs";
 export const routerDir = "/routers";
 export const routerExtension = ".router";
 export const defaultRouter = "index";
+export const debounceTimeSpan = 10;

package/src/core/aws/api-gateway.ts

@@ -0,0 +1,187 @@
+import {
+  APIGatewayClient,
+  CreateRestApiCommand,
+  GetRestApisCommand,
+  CreateResourceCommand,
+  PutMethodCommand,
+  PutIntegrationCommand,
+  CreateDeploymentCommand,
+  GetResourcesCommand,
+} from "@aws-sdk/client-api-gateway";
+import { LambdaClient, AddPermissionCommand } from "@aws-sdk/client-lambda";
+
+/**
+ * Comprehensive TypeScript library for managing AWS API Gateway REST APIs
+ * and linking them to AWS Lambda functions.
+ * Supports full lifecycle: API creation, resource/method setup,
+ * Lambda integration, permissions, and deployment.
+ */
+export class APIGateway {
+  public apiGateway!: APIGatewayClient;
+  public lambda!: LambdaClient;
+
+  /**
+   * Creates an instance of APIGatewayLambdaLinker.
+   * @param options - Configuration options.
+   * @param [options.region=us-east-1] - AWS region for operations.
+   */
+  public constructor(region?: string, ...args: any[]) {
+    if (region == null) {
+      this.apiGateway = new APIGatewayClient({ region, ...args });
+      this.lambda = new LambdaClient({ region, ...args });
+    }
+  }
+
+  /**
+   * Creates a new REST API in API Gateway.
+   * @param name - Unique name for the REST API.
+   * @param [description] - Optional description of the API.
+   * @returns Promise resolving to the created RestApi object containing API ID and details.
+   * @throws Will throw if API creation fails (e.g., duplicate name, permissions).
+   */
+  public async createRestApi(name: string, description?: string): Promise<any> {
+    const command = new CreateRestApiCommand({
+      name,
+      description,
+      endpointConfiguration: { types: ["REGIONAL"] },
+    });
+    return this.apiGateway.send(command);
+  }
+
+  /**
+   * Lists all REST APIs in the current region.
+   * @returns Promise resolving to array of RestApi objects or empty array.
+   */
+  public async listRestApis(): Promise<any[]> {
+    const command = new GetRestApisCommand({});
+    const response = await this.apiGateway.send(command);
+    return response.items || [];
+  }
+
+  /**
+   * Retrieves all resources for a specific REST API.
+   * @param restApiId - The ID of the REST API.
+   * @returns Promise resolving to array of Resource objects or empty array.
+   */
+  public async getResources(restApiId: string): Promise<any[]> {
+    const command = new GetResourcesCommand({ restApiId });
+    const response = await this.apiGateway.send(command);
+    return response.items || [];
+  }
+
+  /**
+   * Creates a new resource (path segment) under a parent resource.
+   * Use root resource (path '/') as parentId for top-level paths like '/items'.
+   * @param restApiId - The ID of the REST API.
+   * @param parentId - ID of the parent resource.
+   * @param pathPart - Path segment name (e.g., 'items' for '/items').
+   * @returns Promise resolving to the created Resource object.
+   */
+  public async createResource(
+    restApiId: string,
+    parentId: string,
+    pathPart: string
+  ): Promise<any> {
+    const command = new CreateResourceCommand({
+      restApiId,
+      parentId,
+      pathPart,
+    });
+    return this.apiGateway.send(command);
+  }
+
+  /**
+   * Creates or updates an HTTP method on a resource.
+   * @param restApiId - The ID of the REST API.
+   * @param resourceId - The ID of the resource.
+   * @param httpMethod - HTTP method (GET, POST, PUT, DELETE, etc.).
+   * @param [authorizationType="NONE"] - Authorization type (NONE, AWS_IAM, CUSTOM, COGNITO_USER_POOLS).
+   * @returns Promise resolving to the method configuration.
+   */
+  public async putMethod(
+    restApiId: string,
+    resourceId: string,
+    httpMethod: string,
+    authorizationType: string = "NONE"
+  ): Promise<any> {
+    const command = new PutMethodCommand({
+      restApiId,
+      resourceId,
+      httpMethod,
+      authorizationType,
+      apiKeyRequired: false,
+    });
+    return this.apiGateway.send(command);
+  }
+
+  /**
+   * Links a Lambda function as the backend integration for an HTTP method using AWS_PROXY integration.
+   * @param restApiId - The ID of the REST API.
+   * @param resourceId - The ID of the resource.
+   * @param httpMethod - HTTP method (must match previously created method).
+   * @param lambdaArn - Full ARN of the Lambda function.
+   * @returns Promise resolving to the integration configuration.
+   */
+  public async putIntegration(
+    restApiId: string,
+    resourceId: string,
+    httpMethod: string,
+    lambdaArn: string
+  ): Promise<any> {
+    const region = this.apiGateway.config.region || "us-east-1";
+    const command = new PutIntegrationCommand({
+      restApiId,
+      resourceId,
+      httpMethod,
+      type: "AWS_PROXY",
+      integrationHttpMethod: "POST",
+      uri: `arn:aws:apigateway:${region}:lambda:path/2015-03-31/functions/${lambdaArn}/invocations`,
+    });
+    return this.apiGateway.send(command);
+  }
+
+  /**
+   * Adds Lambda execution permission for API Gateway to invoke the function.
+   * Required for Lambda integration to work.
+   * @param functionName - Name or ARN of the Lambda function.
+   * @param statementId - Unique ID for this permission statement.
+   * @param restApiId - The ID of the REST API.
+   * @param region - AWS region.
+   * @param accountId - AWS account ID (12 digits).
+   * @returns Promise resolving to the permission policy statement.
+   */
+  public async addLambdaPermission(
+    functionName: string,
+    statementId: string,
+    restApiId: string,
+    region: string,
+    accountId: string
+  ): Promise<any> {
+    const sourceArn = `arn:aws:execute-api:${region}:${accountId}:${restApiId}/*/*/*`;
+    const command = new AddPermissionCommand({
+      FunctionName: functionName,
+      StatementId: statementId,
+      Action: "lambda:InvokeFunction",
+      Principal: "apigateway.amazonaws.com",
+      SourceArn: sourceArn,
+    });
+    return this.lambda.send(command);
+  }
+
+  /**
+   * Deploys the REST API to a specific stage, making it accessible via invoke URL.
+   * @param restApiId - The ID of the REST API.
+   * @param stageName - Stage name (dev, prod, test, etc.).
+   * @returns Promise resolving to the deployment object.
+   */
+  public async createDeployment(
+    restApiId: string,
+    stageName: string
+  ): Promise<any> {
+    const command = new CreateDeploymentCommand({
+      restApiId,
+      stageName,
+    });
+    return this.apiGateway.send(command);
+  }
+}

package/src/core/aws/basic-types.ts

@@ -0,0 +1,147 @@
+import { Runtime } from "@aws-sdk/client-lambda";
+
+/**
+ * Lambda function creation parameters
+ * @see https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html
+ */
+export interface LambdaCreateParams {
+  /** Lambda function name to create or update (if already exists) in AWS */
+  functionName: string;
+  /**
+   * IAM role ARN
+   *
+   * @default arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
+   * @see https://docs.aws.amazon.com/lambda/latest/dg/lambda-permissions.html
+   */
+  roleArn: string;
+  /**
+   * Path to zip file containing lambda code
+   *
+   * @default index.zip
+   * @see https://docs.aws.amazon.com/lambda/latest/dg/lambda-zip-file-format.html
+   */
+  zipFilePath: string;
+  /**
+   * Lambda handler
+   *
+   * @default index.handler
+   */
+  handler: string;
+  /**
+   * Lambda runtime
+   *
+   * @default Runtime.nodejs18x
+   */
+  runtime?: Runtime;
+  /**
+   * Timeout in seconds
+   *
+   * @default 15
+   */
+  timeout?: number;
+  /**
+   * Memory size in MB
+   *
+   * @default 128
+   */
+  memorySize?: number;
+  /**
+   * Environment variables
+   *
+   * @default {}
+   * @see https://docs.aws.amazon.com/lambda/latest/dg/lambda-environment-variables.html
+   */
+  environment?: Record<string, string>;
+  /**
+   * AWS region
+
+   * @see https://docs.aws.amazon.com/lambda/latest/dg/configuration-regions.html
+   */
+  region?: string;
+}
+
+/**
+ * Parameters for uploading a file to an S3 bucket
+ */
+export interface UploadParams {
+  bucket: string;
+  /** Key of the object to create in the bucket */
+  key: string;
+  filePath: string;
+  /**
+   * Additional parameters to pass to the PutObjectCommand
+   * @see https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html
+   */
+  extraArgs?: Record<string, any>;
+}
+
+/**
+ * Parameters for downloading an object from an S3 bucket
+ */
+export interface DownloadParams {
+  bucket: string;
+  /** Key of the object to create in the bucket */
+  key: string;
+  destPath: string;
+}
+
+/**
+ * Email message configuration for SES.
+ */
+export interface EmailMessage {
+  /** Recipient email addresses. */
+  to: string[];
+  /** Optional CC recipient email addresses. */
+  cc?: string[];
+  /** Optional BCC recipient email addresses. */
+  bcc?: string[];
+  /** Email subject line. */
+  subject: string;
+  /** Plain text body content. */
+  textBody?: string;
+  /** HTML body content. */
+  htmlBody?: string;
+  /** Sender email address (must be SES verified). */
+  from: string;
+  /** Optional reply-to email addresses. */
+  replyTo?: string[];
+}
+
+/**
+ * SMS message configuration for SNS.
+ */
+export interface SMSMessage {
+  /** Phone number in E.164 format (e.g., '+15551234567'). */
+  phoneNumber: string;
+  /** Message content (max 160 characters for standard SMS). */
+  message: string;
+  /** Optional message attributes for customization. */
+  attributes?: Record<string, any>;
+}
+
+// Define a strict, explicit cache type
+export interface PushPlatformArns {
+  /**
+   * ARN for the APNS platform application
+   * @see https://docs.aws.amazon.com/sns/latest/dg/SNSMobilePush.html
+   */
+  apns?: string;
+  /**
+   * ARN for the APNS_SANDBOX platform application
+   * @see https://docs.aws.amazon.com/sns/latest/dg/SNSMobilePush.html
+   */
+  apns_sandbox?: string;
+  /**
+   * ARN for the FCM platform application
+   * @see https://docs.aws.amazon.com/sns/latest/dg/SNSMobilePush.html
+   */
+  fcm?: string;
+  /**
+   * ARN for the ADM platform application
+   * @see https://docs.aws.amazon.com/sns/latest/dg/SNSMobilePush.html
+   */
+  adm?: string;
+
+  /** Additional platforms as needed in a controlled manner */
+  [platform: string]: string | undefined;
+}