quidproquo-actionprocessor-awslambda 0.0.199 → 0.0.201

package/lib/esm/logic/lambda/executeLambdaByName.js

@@ -0,0 +1,25 @@
+import { LambdaClient, InvokeCommand } from '@aws-sdk/client-lambda';
+import { createAwsClient } from '../createAwsClient';
+export const executeLambdaByName = async (functionName, region, payload, isAsync) => {
+    const lambdaClient = createAwsClient(LambdaClient, { region });
+    const encoder = new TextEncoder();
+    const encodedPayload = encoder.encode(JSON.stringify(payload));
+    const response = await lambdaClient.send(new InvokeCommand({
+        FunctionName: functionName,
+        Payload: encodedPayload,
+        InvocationType: isAsync ? 'Event' : 'RequestResponse',
+    }));
+    if (response.FunctionError) {
+        // Get more details about the error if available
+        const errorDetails = response.Payload ? new TextDecoder().decode(response.Payload) : '';
+        throw new Error(`Lambda Error: ${response.FunctionError}. Details: ${errorDetails}`);
+    }
+    if (!isAsync && response.Payload) {
+        const jsonString = new TextDecoder().decode(response.Payload);
+        if (jsonString) {
+            const object = JSON.parse(jsonString);
+            return object;
+        }
+    }
+    return undefined;
+};

package/lib/esm/logic/parametersManager/getParameter.d.ts

@@ -0,0 +1 @@
+export declare const getParameter: (parameterName: string, region: string) => Promise<string>;

package/lib/esm/logic/parametersManager/getParameter.js

@@ -0,0 +1,10 @@
+import { SSMClient, GetParameterCommand } from '@aws-sdk/client-ssm';
+import { memoFuncAsync } from '../cache/memoFuncAsync';
+import { createAwsClient } from "../createAwsClient";
+export const getParameter = memoFuncAsync(async (parameterName, region) => {
+    const ssmClient = createAwsClient(SSMClient, { region });
+    const response = await ssmClient.send(new GetParameterCommand({
+        Name: parameterName,
+    }));
+    return response.Parameter?.Value || '';
+}, 60);

package/lib/esm/logic/parametersManager/getParameters.d.ts

@@ -0,0 +1 @@
+export declare const getParameters: (parameterNames: string[], region: string) => Promise<string[]>;

package/lib/esm/logic/parametersManager/getParameters.js

@@ -0,0 +1,11 @@
+import { SSMClient, GetParametersCommand } from '@aws-sdk/client-ssm';
+import { memoFuncAsync } from '../cache/memoFuncAsync';
+import { createAwsClient } from '../createAwsClient';
+export const getParameters = memoFuncAsync(async (parameterNames, region) => {
+    const ssmClient = createAwsClient(SSMClient, { region });
+    const response = await ssmClient.send(new GetParametersCommand({
+        Names: parameterNames,
+    }));
+    const resolvedParams = response.Parameters || [];
+    return parameterNames.map((pn) => resolvedParams.find((rp) => rp.Name == pn)?.Value || '');
+}, 60);

package/lib/esm/logic/parametersManager/setParameter.d.ts

@@ -0,0 +1 @@
+export declare const setParameter: (parameterName: string, region: string, value: string) => Promise<void>;

package/lib/esm/logic/parametersManager/setParameter.js

@@ -0,0 +1,11 @@
+import { SSMClient, PutParameterCommand, ParameterType } from '@aws-sdk/client-ssm';
+import { createAwsClient } from '../createAwsClient';
+export const setParameter = async (parameterName, region, value) => {
+    const ssmClient = createAwsClient(SSMClient, { region });
+    await ssmClient.send(new PutParameterCommand({
+        Name: parameterName,
+        Value: value,
+        Overwrite: true,
+        Type: ParameterType.STRING
+    }));
+};

package/lib/esm/logic/s3/deleteFiles.d.ts

@@ -0,0 +1 @@
+export declare const deleteFiles: (drive: string, filepaths: string[], region: string) => Promise<string[]>;

package/lib/esm/logic/s3/deleteFiles.js

@@ -0,0 +1,14 @@
+import { S3Client, DeleteObjectsCommand } from '@aws-sdk/client-s3';
+import { createAwsClient } from '../createAwsClient';
+export const deleteFiles = async (drive, filepaths, region) => {
+    const s3Client = createAwsClient(S3Client, { region });
+    const bucketParams = {
+        Bucket: drive,
+        Delete: {
+            Quiet: true,
+            Objects: filepaths.map((fp) => ({ Key: fp })),
+        },
+    };
+    const response = await s3Client.send(new DeleteObjectsCommand(bucketParams));
+    return (response.Errors || []).map((e) => e.Key || '');
+};

package/lib/esm/logic/s3/generatePresignedUrl.d.ts

@@ -0,0 +1 @@
+export declare const generatePresignedUrl: (bucketName: string, objectKey: string, region: string, expirationMs: number) => Promise<string>;

package/lib/esm/logic/s3/generatePresignedUrl.js

@@ -0,0 +1,19 @@
+import { GetObjectCommand, S3Client } from '@aws-sdk/client-s3';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+import { createAwsClient } from '../createAwsClient';
+export const generatePresignedUrl = async (bucketName, objectKey, region, expirationMs) => {
+    const s3Client = createAwsClient(S3Client, { region });
+    // Define the command for getting an object, which will be presigned
+    const getObjectCommand = new GetObjectCommand({
+        Bucket: bucketName,
+        Key: objectKey,
+    });
+    try {
+        const url = await getSignedUrl(s3Client, getObjectCommand, { expiresIn: expirationMs / 1000 });
+        return url;
+    }
+    catch (error) {
+        console.error('Error generating presigned URL', error);
+        throw error;
+    }
+};

package/lib/esm/logic/s3/listFiles.d.ts

@@ -0,0 +1,10 @@
+export interface S3FileInfo {
+    filepath: string;
+    isDir: boolean;
+    hashMd5?: string;
+}
+export interface S3FileList {
+    fileInfos: S3FileInfo[];
+    pageToken?: string;
+}
+export declare const listFiles: (bucketName: string, region: string, folder?: string, maxKeys?: number, pageToken?: string) => Promise<S3FileList>;

package/lib/esm/logic/s3/listFiles.js

@@ -0,0 +1,42 @@
+import { S3Client } from '@aws-sdk/client-s3';
+import { ListObjectsV2Command } from '@aws-sdk/client-s3';
+import { filePathDelimiter } from 'quidproquo-core';
+import { createAwsClient } from '../createAwsClient';
+export const listFiles = async (bucketName, region, folder = '', maxKeys = 1000, pageToken) => {
+    const validatedPrefix = `${folder}${folder.endsWith(filePathDelimiter) || !folder ? '' : filePathDelimiter}`;
+    const bucketParams = {
+        Bucket: bucketName,
+        Delimiter: filePathDelimiter,
+        Prefix: validatedPrefix,
+        ContinuationToken: pageToken,
+        MaxKeys: maxKeys,
+    };
+    // Declare truncated as a flag that the while loop is based on.
+    let files = [];
+    const s3Client = createAwsClient(S3Client, { region });
+    const response = await s3Client.send(new ListObjectsV2Command(bucketParams));
+    if (response.CommonPrefixes && !bucketParams.ContinuationToken) {
+        files = [
+            ...files,
+            ...response.CommonPrefixes.filter((cp) => !!cp.Prefix).map((cp) => ({
+                filepath: cp.Prefix,
+                drive: bucketName,
+                isDir: true,
+            })),
+        ];
+    }
+    files = [
+        ...files,
+        ...(response.Contents || [])
+            .filter((c) => !!c.Key && c.Key != folder)
+            .map((item) => ({
+            filepath: item.Key,
+            isDir: item.Key.endsWith(filePathDelimiter),
+            hashMd5: item.ETag,
+        })),
+    ];
+    return {
+        fileInfos: files,
+        pageToken: response.NextContinuationToken,
+    };
+};

package/lib/esm/logic/s3/objectExists.d.ts

@@ -0,0 +1 @@
+export declare const objectExists: (bucketName: string, key: string, region: string) => Promise<boolean>;

package/lib/esm/logic/s3/objectExists.js

@@ -0,0 +1,16 @@
+import { S3Client } from '@aws-sdk/client-s3';
+import { HeadObjectCommand } from '@aws-sdk/client-s3';
+import { createAwsClient } from '../createAwsClient';
+export const objectExists = async (bucketName, key, region) => {
+    try {
+        const s3Client = createAwsClient(S3Client, { region });
+        await s3Client.send(new HeadObjectCommand({
+            Key: key,
+            Bucket: bucketName,
+        }));
+        return true;
+    }
+    catch {
+        return false;
+    }
+};

package/lib/esm/logic/s3/readBinaryFile.d.ts

@@ -0,0 +1,2 @@
+import { QPQBinaryData } from 'quidproquo-core';
+export declare const readBinaryFile: (bucketName: string, key: string, region: string) => Promise<QPQBinaryData>;

package/lib/esm/logic/s3/readBinaryFile.js

@@ -0,0 +1,15 @@
+import { S3Client, GetObjectCommand } from '@aws-sdk/client-s3';
+import { createAwsClient } from '../createAwsClient';
+export const readBinaryFile = async (bucketName, key, region) => {
+    const s3Client = createAwsClient(S3Client, { region });
+    const response = await s3Client.send(new GetObjectCommand({
+        Key: key,
+        Bucket: bucketName,
+    }));
+    return {
+        base64Data: await response.Body?.transformToString('base64'),
+        mimetype: response.ContentType,
+        filename: key.split('/').pop(),
+        contentDisposition: response.ContentDisposition,
+    };
+};

package/lib/esm/logic/s3/readTextFile.d.ts

@@ -0,0 +1 @@
+export declare const readTextFile: (bucketName: string, key: string, region: string) => Promise<string>;

package/lib/esm/logic/s3/readTextFile.js

@@ -0,0 +1,10 @@
+import { S3Client, GetObjectCommand } from '@aws-sdk/client-s3';
+import { createAwsClient } from '../createAwsClient';
+export const readTextFile = async (bucketName, key, region) => {
+    const s3Client = createAwsClient(S3Client, { region });
+    const response = await s3Client.send(new GetObjectCommand({
+        Key: key,
+        Bucket: bucketName,
+    }));
+    return (await response.Body?.transformToString()) || '';
+};

package/lib/esm/logic/s3/s3Utils.d.ts

@@ -0,0 +1,7 @@
+export * from './deleteFiles';
+export * from './listFiles';
+export * from './objectExists';
+export * from './readTextFile';
+export * from './writeTextFile';
+export * from './readBinaryFile';
+export * from './writeBinaryFile';

package/lib/esm/logic/s3/s3Utils.js

@@ -0,0 +1,7 @@
+export * from './deleteFiles';
+export * from './listFiles';
+export * from './objectExists';
+export * from './readTextFile';
+export * from './writeTextFile';
+export * from './readBinaryFile';
+export * from './writeBinaryFile';

package/lib/esm/logic/s3/writeBinaryFile.d.ts

@@ -0,0 +1,3 @@
+import { QPQBinaryData } from 'quidproquo-core';
+import { StorageClass } from '@aws-sdk/client-s3';
+export declare const writeBinaryFile: (bucketName: string, key: string, data: QPQBinaryData, region: string, storageClass: keyof typeof StorageClass) => Promise<void>;

package/lib/esm/logic/s3/writeBinaryFile.js

@@ -0,0 +1,13 @@
+import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';
+import { createAwsClient } from '../createAwsClient';
+export const writeBinaryFile = async (bucketName, key, data, region, storageClass) => {
+    const s3Client = createAwsClient(S3Client, { region });
+    await s3Client.send(new PutObjectCommand({
+        Key: key,
+        Bucket: bucketName,
+        Body: Buffer.from(data.base64Data, 'base64'),
+        ContentType: data.mimetype,
+        ContentDisposition: data.contentDisposition,
+        StorageClass: storageClass
+    }));
+};

package/lib/esm/logic/s3/writeTextFile.d.ts

@@ -0,0 +1,2 @@
+import { StorageClass } from '@aws-sdk/client-s3';
+export declare const writeTextFile: (bucketName: string, key: string, data: string, region: string, storageClass: keyof typeof StorageClass) => Promise<void>;

package/lib/esm/logic/s3/writeTextFile.js

@@ -0,0 +1,11 @@
+import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';
+import { createAwsClient } from '../createAwsClient';
+export const writeTextFile = async (bucketName, key, data, region, storageClass) => {
+    const s3Client = createAwsClient(S3Client, { region });
+    await s3Client.send(new PutObjectCommand({
+        Key: key,
+        Bucket: bucketName,
+        Body: Buffer.from(data),
+        StorageClass: storageClass
+    }));
+};

package/lib/esm/logic/secretsManager/getSecret.d.ts

@@ -0,0 +1 @@
+export declare const getSecret: (secretName: string, region: string) => Promise<string>;

package/lib/esm/logic/secretsManager/getSecret.js

@@ -0,0 +1,14 @@
+import { SecretsManagerClient, GetSecretValueCommand } from '@aws-sdk/client-secrets-manager';
+import { memoFuncAsync } from '../cache/memoFuncAsync';
+import { createAwsClient } from '../createAwsClient';
+export const getSecret = memoFuncAsync(async (secretName, region) => {
+    const secretsManagerClient = createAwsClient(SecretsManagerClient, { region });
+    const response = await secretsManagerClient.send(new GetSecretValueCommand({
+        SecretId: secretName,
+    }));
+    const secretValue = response.SecretString || '';
+    if (!secretValue) {
+        throw new Error(`Failed to get secret value for secret name: [${secretName}]`);
+    }
+    return secretValue;
+}, 60);

package/lib/esm/logic/sns/publishMessage.d.ts

@@ -0,0 +1 @@
+export declare const publishMessage: (topicArn: string, region: string, messages: string[]) => Promise<void>;

package/lib/esm/logic/sns/publishMessage.js

@@ -0,0 +1,28 @@
+import { PublishBatchCommand, SNSClient, } from '@aws-sdk/client-sns';
+import { createAwsClient } from '../createAwsClient';
+export const publishMessage = async (topicArn, region, messages) => {
+    const sqsClient = createAwsClient(SNSClient, { region });
+    // Convert them to entries
+    const entries = messages.map((message, index) => ({
+        Message: message,
+        Id: `${index}`,
+        // MessageAttributes: {
+        //   type: {
+        //     DataType: 'String',
+        //     StringValue: JSON.parse(message).type,
+        //   },
+        // },
+    }));
+    // now send them off in batches of 10
+    // We want to await incase of FIFO
+    // If you don't care about order, you can split and askParallel outside of this
+    while (entries.length > 0) {
+        // Not sure the max batch size, although the entire payload cant be bigger then 256 KB
+        // TODO: So maybe we should split based on payload sizes
+        const entriesBatch = entries.splice(0, 10);
+        await sqsClient.send(new PublishBatchCommand({
+            TopicArn: topicArn,
+            PublishBatchRequestEntries: entriesBatch,
+        }));
+    }
+};

package/lib/esm/logic/sqs/getQueueUrl.d.ts

@@ -0,0 +1,2 @@
+import { SQSClient } from '@aws-sdk/client-sqs';
+export declare const getQueueUrl: (queueName: string, sqsClient: SQSClient) => Promise<string>;

package/lib/esm/logic/sqs/getQueueUrl.js

@@ -0,0 +1,7 @@
+import { GetQueueUrlCommand } from '@aws-sdk/client-sqs';
+export const getQueueUrl = async (queueName, sqsClient) => {
+    const response = await sqsClient.send(new GetQueueUrlCommand({
+        QueueName: queueName,
+    }));
+    return response.QueueUrl || '';
+};

package/lib/esm/logic/sqs/sendMessages.d.ts

@@ -0,0 +1 @@
+export declare const sendMessages: (queueName: string, region: string, messages: string[]) => Promise<void>;

package/lib/esm/logic/sqs/sendMessages.js

@@ -0,0 +1,23 @@
+import { SendMessageBatchCommand, SQSClient, } from '@aws-sdk/client-sqs';
+import { getQueueUrl } from './getQueueUrl';
+import { createAwsClient } from '../createAwsClient';
+export const sendMessages = async (queueName, region, messages) => {
+    const sqsClient = createAwsClient(SQSClient, { region });
+    const url = await getQueueUrl(queueName, sqsClient);
+    // Convert them to entries
+    const entries = messages.map((message, index) => ({
+        MessageBody: message,
+        Id: `${index}`,
+    }));
+    // now send them off in batches of 10
+    // We want to await incase of FIFO
+    // If you don't care about order, you can split and askParallel outside of this
+    while (entries.length > 0) {
+        // Max batch size is 10
+        const entriesBatch = entries.splice(0, 10);
+        await sqsClient.send(new SendMessageBatchCommand({
+            Entries: entriesBatch,
+            QueueUrl: url,
+        }));
+    }
+};

package/lib/esm/runtimeConfig/QPQAWSResourceMap.d.ts

@@ -0,0 +1,4 @@
+export interface LambdaRuntimeConfig {
+    src: string;
+    runtime: string;
+}

package/lib/esm/runtimeConfig/QPQAWSResourceMap.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/runtimeConfig/qpqAwsLambdaRuntimeConfigUtils.d.ts

@@ -0,0 +1,4 @@
+import { QPQConfig } from 'quidproquo-core';
+export declare const resolveResourceName: (resourceName: string, qpqConfig: QPQConfig) => string;
+export declare const resolveSecretKey: (secretName: string, qpqConfig: QPQConfig) => string;
+export declare const resolveParameterKey: (parameterName: string, qpqConfig: QPQConfig) => string;

package/lib/esm/runtimeConfig/qpqAwsLambdaRuntimeConfigUtils.js

@@ -0,0 +1,12 @@
+import { qpqCoreUtils } from 'quidproquo-core';
+import { getConfigRuntimeResourceNameFromConfig, getConfigRuntimeResourceNameFromConfigWithServiceOverride, } from '../awsNamingUtils';
+export const resolveResourceName = (resourceName, qpqConfig) => {
+    return getConfigRuntimeResourceNameFromConfig(resourceName, qpqConfig);
+};
+export const resolveSecretKey = (secretName, qpqConfig) => {
+    return getConfigRuntimeResourceNameFromConfig(secretName, qpqConfig);
+};
+export const resolveParameterKey = (parameterName, qpqConfig) => {
+    const secretConfig = qpqCoreUtils.getParameterConfig(parameterName, qpqConfig);
+    return getConfigRuntimeResourceNameFromConfigWithServiceOverride(secretConfig.owner?.resourceNameOverride || parameterName, qpqConfig, secretConfig.owner?.module);
+};

package/lib/esm/types/DynamicLoader.d.ts

@@ -0,0 +1 @@
+export type DynamicModuleLoader = (src: string) => Promise<any>;

package/lib/esm/types/DynamicLoader.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/types/index.d.ts

@@ -0,0 +1 @@
+export * from './DynamicLoader';

package/lib/esm/types/index.js

@@ -0,0 +1 @@
+export * from './DynamicLoader';

package/package.json

@@ -1,17 +1,21 @@
 {
   "name": "quidproquo-actionprocessor-awslambda",
-  "version": "0.0.199",
+  "version": "0.0.201",
   "description": "",
   "main": "./lib/commonjs/index.js",
-  "types": "./lib/commonjs/index.d.ts",
+  "module": "./lib/esm/index.js",
+  "types": "./lib/esm/index.d.ts",
+  "sideEffects": false,
   "files": [
     "lib/**/*"
   ],
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
     "clean": "npx rimraf lib && npx rimraf node_modules",
-    "build": "npm run clean && tsc -p tsconfig.commonjs.json",
-    "watch": "tsc -p tsconfig.commonjs.json -w"
+    "build": "npm run clean && npm run build:esm && npm run build:cjs",
+    "watch": "tsc -p tsconfig.esm.json -w",
+    "build:cjs": "tsc -p tsconfig.commonjs.json",
+    "build:esm": "tsc -p tsconfig.esm.json"
   },
   "repository": {
     "type": "git",
@@ -47,9 +51,9 @@
     "lodash": "^4.17.21",
     "node-cache": "^5.1.2",
     "node-match-path": "^0.6.3",
-    "quidproquo-config-aws": "0.0.199",
-    "quidproquo-core": "0.0.199",
-    "quidproquo-webserver": "0.0.199"
+    "quidproquo-config-aws": "0.0.201",
+    "quidproquo-core": "0.0.201",
+    "quidproquo-webserver": "0.0.201"
   },
   "devDependencies": {
     "@types/aws-lambda": "^8.10.109",
@@ -57,7 +61,7 @@
     "@types/jsonwebtoken": "^9.0.2",
     "@types/lodash": "^4.14.194",
     "@types/node": "^18.11.9",
-    "quidproquo-tsconfig": "0.0.199",
+    "quidproquo-tsconfig": "0.0.201",
     "typescript": "^4.9.3"
   }
 }