codeweaver 3.1.3 → 4.0.0

package/src/core/aws/dynamodb.ts

@@ -0,0 +1,187 @@
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import {
+  DynamoDBDocumentClient,
+  PutCommand,
+  GetCommand,
+  UpdateCommand,
+  DeleteCommand,
+  QueryCommand,
+  ScanCommand,
+  PutCommandInput,
+  GetCommandInput,
+  UpdateCommandInput,
+  DeleteCommandInput,
+  QueryCommandInput,
+  ScanCommandInput,
+} from "@aws-sdk/lib-dynamodb";
+
+export function createDocClient(
+  region?: string,
+  ...args: any[]
+): DynamoDBDocumentClient {
+  const client = new DynamoDBClient({ region, ...args });
+  return DynamoDBDocumentClient.from(client);
+}
+
+// Basic wrappers (more convenient with document client)
+export async function putItem<T>(
+  docClient: DynamoDBDocumentClient,
+  tableName: string,
+  item: T
+) {
+  const command = new PutCommand({
+    TableName: tableName,
+    Item: item as any,
+  } as PutCommandInput);
+  return docClient.send(command);
+}
+
+export async function getItem<T>(
+  docClient: DynamoDBDocumentClient,
+  tableName: string,
+  key: Record<string, any>
+): Promise<T | undefined> {
+  const command = new GetCommand({
+    TableName: tableName,
+    Key: key,
+  } as GetCommandInput);
+  const resp = await docClient.send(command);
+  return (resp.Item as T) ?? undefined;
+}
+
+export async function updateItem<T>(
+  docClient: DynamoDBDocumentClient,
+  tableName: string,
+  key: Record<string, any>,
+  updateExpression: string,
+  expressionAttributeValues: Record<string, any>,
+  conditionExpression?: string
+): Promise<T | undefined> {
+  const command = new UpdateCommand({
+    TableName: tableName,
+    Key: key,
+    UpdateExpression: updateExpression,
+    ExpressionAttributeValues: expressionAttributeValues,
+    ConditionExpression: conditionExpression,
+    ReturnValues: "ALL_NEW",
+  } as UpdateCommandInput);
+  const resp = await docClient.send(command);
+  return resp.Attributes as unknown as T;
+}
+
+export async function deleteItem(
+  docClient: DynamoDBDocumentClient,
+  tableName: string,
+  key: Record<string, any>
+): Promise<void> {
+  const command = new DeleteCommand({
+    TableName: tableName,
+    Key: key,
+  } as DeleteCommandInput);
+  await docClient.send(command);
+}
+
+export async function queryItems<T>(
+  docClient: DynamoDBDocumentClient,
+  tableName: string,
+  keyConditionExpression: string,
+  expressionAttributeValues: Record<string, any>,
+  indexName?: string
+): Promise<T[]> {
+  const command = new QueryCommand({
+    TableName: tableName,
+    IndexName: indexName,
+    KeyConditionExpression: keyConditionExpression,
+    ExpressionAttributeValues: expressionAttributeValues,
+  } as QueryCommandInput);
+  const resp = await docClient.send(command);
+  return (resp.Items as T[]) ?? [];
+}
+
+export async function scanItems<T>(
+  docClient: DynamoDBDocumentClient,
+  tableName: string,
+  filterExpression?: string,
+  expressionAttributeValues?: Record<string, any>,
+  indexName?: string
+): Promise<T[]> {
+  const command = new ScanCommand({
+    TableName: tableName,
+    FilterExpression: filterExpression,
+    ExpressionAttributeValues: expressionAttributeValues,
+    IndexName: indexName,
+  } as ScanCommandInput);
+  const resp = await docClient.send(command);
+  return (resp.Items as T[]) ?? [];
+}
+
+export class DynamoRepository<T extends { [key: string]: any }> {
+  public docClient!: DynamoDBDocumentClient;
+  private tableName: string;
+
+  public constructor(tableName: string, region?: string, ...args: any[]) {
+    this.tableName = tableName;
+    if (region != null) {
+      this.docClient = createDocClient(region, ...args);
+    }
+  }
+
+  public async put(item: T): Promise<void> {
+    // You may want to enforce key presence here
+    await putItem(this.docClient, this.tableName, item);
+  }
+
+  public async get(key: Record<string, any>): Promise<T | undefined> {
+    return (await getItem<T>(this.docClient, this.tableName, key)) as
+      | T
+      | undefined;
+  }
+
+  public async update(
+    key: Record<string, any>,
+    updateExpression: string,
+    expressionAttributeValues: Record<string, any>,
+    conditionExpression?: string
+  ): Promise<T | undefined> {
+    return await updateItem<T>(
+      this.docClient,
+      this.tableName,
+      key,
+      updateExpression,
+      expressionAttributeValues,
+      conditionExpression
+    );
+  }
+
+  public async delete(key: Record<string, any>): Promise<void> {
+    await deleteItem(this.docClient, this.tableName, key);
+  }
+
+  public async query(
+    keyConditionExpression: string,
+    expressionAttributeValues: Record<string, any>,
+    indexName?: string
+  ): Promise<T[]> {
+    return await queryItems<T>(
+      this.docClient,
+      this.tableName,
+      keyConditionExpression,
+      expressionAttributeValues,
+      indexName
+    );
+  }
+
+  public async scan(
+    filterExpression?: string,
+    expressionAttributeValues?: Record<string, any>,
+    indexName?: string
+  ): Promise<T[]> {
+    return await scanItems<T>(
+      this.docClient,
+      this.tableName,
+      filterExpression,
+      expressionAttributeValues,
+      indexName
+    );
+  }
+}

package/src/core/aws/index.ts

@@ -0,0 +1,9 @@
+export * from "./basic-types";
+export * from "./utilities";
+export * from "./lambda";
+export * from "./s3";
+export * from "./api-gateway";
+export * from "./message";
+export * from "./message-broker";
+export * from "./api-gateway";
+export * from "./dynamodb";

package/src/core/aws/lambda.ts

@@ -0,0 +1,199 @@
+import {
+  LambdaClient,
+  CreateFunctionCommand,
+  GetFunctionCommand,
+  UpdateFunctionCodeCommand,
+  UpdateFunctionConfigurationCommand,
+  InvokeCommand,
+  ListFunctionsCommand,
+  DeleteFunctionCommand,
+  Runtime,
+} from "@aws-sdk/client-lambda";
+import { LambdaCreateParams } from "./basic-types";
+import { retry, RetryOptions } from "./utilities";
+import fs from "fs";
+import util from "util";
+
+/**
+ * Client for interacting with AWS Lambda functions.
+ */
+export class Lambda {
+  public client: LambdaClient;
+
+  /**
+   * Constructor for LambdaClient.
+   * @param {string} [region] - The AWS region to use for the client.
+   * If not provided, the default region will be used.
+   */
+  public constructor(region?: string, ...args: any[]) {
+    if (region != null) {
+      this.client = new LambdaClient({ region, ...args });
+    }
+  }
+
+  /**
+   * Tries to update or create a Lambda function.
+   * If the function already exists, it will be updated.
+   * If the function does not exist, it will be created.
+   *
+   * @throws If the function could not be updated or created
+   */
+  public async createOrUpdateFunction(
+    params: LambdaCreateParams,
+    shouldRetry = false,
+    retryOptions?: RetryOptions
+  ): Promise<void> {
+    const {
+      functionName,
+      roleArn,
+      zipFilePath,
+      handler,
+      runtime = Runtime.nodejs18x,
+      timeout = 15,
+      memorySize = 128,
+      environment,
+    } = params;
+
+    const codeBytes = await this.readZip(zipFilePath);
+
+    /**
+     * Tries to update or create a Lambda function.
+     * If the function already exists, it will be updated.
+     * If the function does not exist, it will be created.
+     *
+     * @throws If the function could not be updated or created
+     */
+    const upsert = async () => {
+      try {
+        // Try to get function to decide between update vs create
+        await this.client.send(
+          new GetFunctionCommand({ FunctionName: functionName })
+        );
+
+        // Update
+        await this.client.send(
+          new UpdateFunctionCodeCommand({
+            FunctionName: functionName,
+            ZipFile: codeBytes,
+          })
+        );
+        await this.client.send(
+          new UpdateFunctionConfigurationCommand({
+            FunctionName: functionName,
+            Role: roleArn,
+            Handler: handler,
+            Runtime: runtime,
+            Timeout: timeout,
+            MemorySize: memorySize,
+            Environment: environment ? { Variables: environment } : undefined,
+          })
+        );
+      } catch (err: any) {
+        const isNotFound =
+          err.name === "ResourceNotFoundException" ||
+          (err.$response && err.$response.statusCode === 404);
+        if (isNotFound) {
+          // Create
+          await this.client.send(
+            new CreateFunctionCommand({
+              FunctionName: functionName,
+              Runtime: runtime,
+              Role: roleArn,
+              Handler: handler,
+              Code: { ZipFile: codeBytes },
+              Timeout: timeout,
+              MemorySize: memorySize,
+              Environment: environment ? { Variables: environment } : undefined,
+            })
+          );
+        } else {
+          throw err;
+        }
+      }
+    };
+
+    retry(upsert, retryOptions);
+  }
+
+  /**
+   * Invoke a lambda function.
+   *
+   * @param functionName Name of the lambda function to invoke.
+   * @param payload Payload to pass to the lambda function.
+   * @param invocationType Invocation type; "RequestResponse" for synchronous invocation,
+   *   "Event" for asynchronous invocation.
+   * @returns The response from the lambda function, normalized to a Buffer.
+   */
+  public async invoke(
+    functionName: string,
+    payload: any,
+    invocationType: "RequestResponse" | "Event" = "RequestResponse"
+  ): Promise<Buffer> {
+    const cmd = new InvokeCommand({
+      FunctionName: functionName,
+      Payload:
+        typeof payload === "string"
+          ? payload
+          : Buffer.from(JSON.stringify(payload)),
+      InvocationType: invocationType,
+    });
+
+    const resp = await this.client.send(cmd);
+    // Payload is a streaming or binary blob; normalize to Buffer
+    if (resp.Payload instanceof Uint8Array) {
+      return Buffer.from(resp.Payload);
+    }
+    if (resp.Payload) {
+      // Attempt to read as Buffer if possible
+      try {
+        const chunks: Buffer[] = [];
+        for await (const chunk of resp.Payload as any) {
+          chunks.push(Buffer.from(chunk));
+        }
+        return Buffer.concat(chunks);
+      } catch {
+        // If not iterable, fall back to empty
+        return Buffer.alloc(0);
+      }
+    }
+    return Buffer.alloc(0);
+  }
+
+  /**
+   * Lists all Lambda functions with an optional prefix filter.
+   * @param {string} [prefix] - Optional prefix to filter functions by.
+   * @returns {Promise<any[]>} - A Promise resolving with an array of Lambda functions.
+   */
+  public async listFunctions(prefix?: string): Promise<any[]> {
+    const cmd = new ListFunctionsCommand({});
+    const resp: any = await this.client.send(cmd);
+    let items: any[] = resp.Functions || [];
+    if (prefix) {
+      items = items.filter((f) => f.FunctionName?.startsWith(prefix));
+    }
+    return items;
+  }
+
+  /**
+   * Deletes a Lambda function.
+   * @param functionName The name of the Lambda function to delete.
+   * @returns A Promise resolving when the function is deleted.
+   */
+  async deleteFunction(functionName: string): Promise<void> {
+    await this.client.send(
+      new DeleteFunctionCommand({ FunctionName: functionName })
+    );
+  }
+
+  /**
+   * Reads a file from the local file system as a zip archive and returns the contents as a Buffer.
+   * @param path The path to the zip archive to read.
+   * @returns A Promise resolving to a Buffer containing the file contents.
+   * @private
+   */
+  private async readZip(path: string): Promise<Buffer> {
+    // Read file using fs.promises
+    const readFile = util.promisify(fs.promises.readFile);
+    return (await readFile(path, undefined)) as Buffer;
+  }
+}

package/src/core/aws/message-broker.ts

@@ -0,0 +1,167 @@
+import {
+  SNSClient,
+  CreateTopicCommand,
+  SubscribeCommand,
+  PublishCommand,
+  DeleteTopicCommand,
+  ListTopicsCommand,
+} from "@aws-sdk/client-sns";
+import {
+  SQSClient,
+  CreateQueueCommand,
+  GetQueueAttributesCommand,
+  ReceiveMessageCommand,
+  DeleteMessageCommand,
+  DeleteQueueCommand,
+} from "@aws-sdk/client-sqs";
+
+/**
+ * SNS-SQS Message Broker for publishing and consuming messages with AWS SNS and SQS.
+ */
+export class AwsSnsSqsBroker {
+  public snsClient!: SNSClient;
+  public sqsClient!: SQSClient;
+
+  public constructor(region?: string, ...args: any[]) {
+    if (region != null) {
+      this.snsClient = new SNSClient({ region, ...args });
+      this.sqsClient = new SQSClient({ region, ...args });
+    }
+  }
+
+  /**
+   * Creates an SNS topic.
+   * @param topicName - The name for the SNS topic.
+   * @returns The ARN of the created topic.
+   */
+  public async createTopic(topicName: string): Promise<string> {
+    const command = new CreateTopicCommand({ Name: topicName });
+    const response = await this.snsClient.send(command);
+    return response.TopicArn!;
+  }
+
+  /**
+   * Deletes an SNS topic by ARN.
+   * @param topicArn - The ARN of the topic to delete.
+   */
+  public async deleteTopic(topicArn: string): Promise<void> {
+    const command = new DeleteTopicCommand({ TopicArn: topicArn });
+    await this.snsClient.send(command);
+  }
+
+  /**
+   * Creates an SQS queue.
+   * @param queueName - The name for the queue.
+   * @param attributes - Optional queue attributes such as visibility timeout.
+   * @returns The URL of the created queue.
+   */
+  public async createQueue(
+    queueName: string,
+    attributes?: Record<string, string>
+  ): Promise<string> {
+    const command = new CreateQueueCommand({
+      QueueName: queueName,
+      Attributes: attributes,
+    });
+    const response = await this.sqsClient.send(command);
+    return response.QueueUrl!;
+  }
+
+  /**
+   * Deletes an SQS queue by URL.
+   * @param queueUrl - The URL of the queue to delete.
+   */
+  public async deleteQueue(queueUrl: string): Promise<void> {
+    const command = new DeleteQueueCommand({ QueueUrl: queueUrl });
+    await this.sqsClient.send(command);
+  }
+
+  /**
+   * Subscribes an SQS queue to an SNS topic.
+   * @param topicArn - ARN of the SNS topic.
+   * @param queueArn - ARN of the SQS queue.
+   * @returns The Subscription ARN.
+   */
+  public async subscribeQueueToTopic(
+    topicArn: string,
+    queueArn: string
+  ): Promise<string> {
+    const command = new SubscribeCommand({
+      TopicArn: topicArn,
+      Protocol: "sqs",
+      Endpoint: queueArn,
+    });
+    const response = await this.snsClient.send(command);
+    return response.SubscriptionArn!;
+  }
+
+  /**
+   * Gets the ARN of an SQS queue from its URL.
+   * @param queueUrl - The URL of the SQS queue.
+   * @returns The ARN string of the queue.
+   */
+  public async getQueueArn(queueUrl: string): Promise<string> {
+    const command = new GetQueueAttributesCommand({
+      QueueUrl: queueUrl,
+      AttributeNames: ["QueueArn"],
+    });
+    const response = await this.sqsClient.send(command);
+    return response.Attributes?.QueueArn || "";
+  }
+
+  /**
+   * Publishes a message to an SNS topic.
+   * @param topicArn - ARN of the SNS topic.
+   * @param message - The message content to send.
+   * @param subject - Optional message subject.
+   */
+  public async publishMessage(
+    topicArn: string,
+    message: string,
+    subject?: string
+  ): Promise<void> {
+    const command = new PublishCommand({
+      TopicArn: topicArn,
+      Message: message,
+      Subject: subject,
+    });
+    await this.snsClient.send(command);
+  }
+
+  /**
+   * Receives messages from an SQS queue.
+   * @param queueUrl - The URL of the SQS queue.
+   * @param maxMessages - Maximum number of messages to receive (default 1).
+   * @param waitTimeSeconds - Long polling wait time in seconds (default 10).
+   * @returns Array of messages received.
+   */
+  public async receiveMessages(
+    queueUrl: string,
+    maxMessages: number = 1,
+    waitTimeSeconds: number = 10
+  ) {
+    const command = new ReceiveMessageCommand({
+      QueueUrl: queueUrl,
+      MaxNumberOfMessages: maxMessages,
+      WaitTimeSeconds: waitTimeSeconds,
+    });
+    const response = await this.sqsClient.send(command);
+    return response.Messages || [];
+  }
+
+  /**
+   * Deletes a message from an SQS queue.
+   * @param queueUrl - The URL of the SQS queue.
+   * @param receiptHandle - The receipt handle of the message to delete.
+   */
+  public async deleteMessage(
+    queueUrl: string,
+    receiptHandle: string
+  ): Promise<void> {
+    const command = new DeleteMessageCommand({
+      QueueUrl: queueUrl,
+      ReceiptHandle: receiptHandle,
+    });
+    await this.sqsClient.send(command);
+  }
+}