quidproquo-actionprocessor-awslambda 0.0.254 → 0.0.255

package/lib/esm/logic/dynamo/qpqDynamoOrm/getDynamoTableIndexByConfigAndQuery.js

@@ -1,22 +1,22 @@
-import { isKvsLogicalOperator, isKvsQueryCondition } from './buildDynamoQuery';
-export const getDynamoTableIndexByConfigAndQuery = (setting, query) => {
-    // Function to extract keys from a query
-    const extractKeysFromQuery = (query) => {
-        if (isKvsQueryCondition(query)) {
-            return [query.key];
-        }
-        else if (isKvsLogicalOperator(query)) {
-            return query.conditions.flatMap(extractKeysFromQuery);
-        }
-        return [];
-    };
-    const queriedKeys = extractKeysFromQuery(query);
-    // Find a matching index
-    for (const index of setting.indexes) {
-        if (queriedKeys.includes(index.partitionKey.key)) {
-            return index.partitionKey.key;
-        }
-    }
-    // No matching index found
-    return undefined;
-};
+import { isKvsLogicalOperator, isKvsQueryCondition } from './buildDynamoQuery';
+export const getDynamoTableIndexByConfigAndQuery = (setting, query) => {
+    // Function to extract keys from a query
+    const extractKeysFromQuery = (query) => {
+        if (isKvsQueryCondition(query)) {
+            return [query.key];
+        }
+        else if (isKvsLogicalOperator(query)) {
+            return query.conditions.flatMap(extractKeysFromQuery);
+        }
+        return [];
+    };
+    const queriedKeys = extractKeysFromQuery(query);
+    // Find a matching index
+    for (const index of setting.indexes) {
+        if (queriedKeys.includes(index.partitionKey.key)) {
+            return index.partitionKey.key;
+        }
+    }
+    // No matching index found
+    return undefined;
+};

package/lib/esm/logic/dynamo/qpqDynamoOrm/index.d.ts

@@ -1,3 +1,3 @@
-export * from './buildDynamoQuery';
-export * from './buildDynamoUpdate';
-export * from './getDynamoTableIndexByConfigAndQuery';
+export * from './buildDynamoQuery';
+export * from './buildDynamoUpdate';
+export * from './getDynamoTableIndexByConfigAndQuery';

package/lib/esm/logic/dynamo/qpqDynamoOrm/index.js

@@ -1,3 +1,3 @@
-export * from './buildDynamoQuery';
-export * from './buildDynamoUpdate';
-export * from './getDynamoTableIndexByConfigAndQuery';
+export * from './buildDynamoQuery';
+export * from './buildDynamoUpdate';
+export * from './getDynamoTableIndexByConfigAndQuery';

package/lib/esm/logic/dynamo/query.d.ts

@@ -1,2 +1,2 @@
-import { KvsQueryOperation, QpqPagedData } from 'quidproquo-core';
-export declare function query<Item>(tableName: string, region: string, keyExpression: KvsQueryOperation, filterExpression?: KvsQueryOperation, pageKey?: string, indexName?: string, limit?: number, sortAscending?: boolean): Promise<QpqPagedData<Item>>;
+import { KvsQueryOperation, QpqPagedData } from 'quidproquo-core';
+export declare function query<Item>(tableName: string, region: string, keyExpression: KvsQueryOperation, filterExpression?: KvsQueryOperation, pageKey?: string, indexName?: string, limit?: number, sortAscending?: boolean): Promise<QpqPagedData<Item>>;

package/lib/esm/logic/dynamo/query.js

@@ -1,28 +1,28 @@
-import { DynamoDBClient, QueryCommand } from '@aws-sdk/client-dynamodb';
-import { createAwsClient } from '../createAwsClient';
-import { itemsToQpqPagedData } from './utils/itemsToQpqPagedData';
-import { convertDynamoMapToObject } from './convertObjectToDynamoMap';
-import { stringToLastEvaluatedKey } from './logs';
-import { buildDynamoQueryExpression, buildExpressionAttributeNames, buildExpressionAttributeValues } from './qpqDynamoOrm';
-export async function query(tableName, region, keyExpression, filterExpression, pageKey, indexName, limit, sortAscending) {
-    // Instantiate DynamoDB client
-    const dynamoDBClient = createAwsClient(DynamoDBClient, { region });
-    const params = {
-        TableName: tableName,
-        KeyConditionExpression: buildDynamoQueryExpression(keyExpression),
-        FilterExpression: filterExpression && buildDynamoQueryExpression(filterExpression),
-        ExpressionAttributeValues: buildExpressionAttributeValues([keyExpression, filterExpression]),
-        ExpressionAttributeNames: buildExpressionAttributeNames([keyExpression, filterExpression]),
-        IndexName: indexName,
-        Limit: limit,
-        ScanIndexForward: sortAscending,
-    };
-    if (pageKey) {
-        params.ExclusiveStartKey = stringToLastEvaluatedKey(pageKey);
-    }
-    // Create QueryCommand
-    const command = new QueryCommand(params);
-    // TODO: Catch errors and throw QPQ ones
-    const data = await dynamoDBClient.send(command);
-    return itemsToQpqPagedData((data.Items?.map((i) => convertDynamoMapToObject(i)) || []), data.LastEvaluatedKey);
-}
+import { DynamoDBClient, QueryCommand } from '@aws-sdk/client-dynamodb';
+import { createAwsClient } from '../createAwsClient';
+import { itemsToQpqPagedData } from './utils/itemsToQpqPagedData';
+import { convertDynamoMapToObject } from './convertObjectToDynamoMap';
+import { stringToLastEvaluatedKey } from './logs';
+import { buildDynamoQueryExpression, buildExpressionAttributeNames, buildExpressionAttributeValues } from './qpqDynamoOrm';
+export async function query(tableName, region, keyExpression, filterExpression, pageKey, indexName, limit, sortAscending) {
+    // Instantiate DynamoDB client
+    const dynamoDBClient = createAwsClient(DynamoDBClient, { region });
+    const params = {
+        TableName: tableName,
+        KeyConditionExpression: buildDynamoQueryExpression(keyExpression),
+        FilterExpression: filterExpression && buildDynamoQueryExpression(filterExpression),
+        ExpressionAttributeValues: buildExpressionAttributeValues([keyExpression, filterExpression]),
+        ExpressionAttributeNames: buildExpressionAttributeNames([keyExpression, filterExpression]),
+        IndexName: indexName,
+        Limit: limit,
+        ScanIndexForward: sortAscending,
+    };
+    if (pageKey) {
+        params.ExclusiveStartKey = stringToLastEvaluatedKey(pageKey);
+    }
+    // Create QueryCommand
+    const command = new QueryCommand(params);
+    // TODO: Catch errors and throw QPQ ones
+    const data = await dynamoDBClient.send(command);
+    return itemsToQpqPagedData((data.Items?.map((i) => convertDynamoMapToObject(i)) || []), data.LastEvaluatedKey);
+}

package/lib/esm/logic/dynamo/scan.d.ts

@@ -1,2 +1,2 @@
-import { KvsQueryOperation, QpqPagedData } from 'quidproquo-core';
-export declare function scan<Item>(tableName: string, region: string, filterExpression?: KvsQueryOperation, pageKey?: string): Promise<QpqPagedData<Item>>;
+import { KvsQueryOperation, QpqPagedData } from 'quidproquo-core';
+export declare function scan<Item>(tableName: string, region: string, filterExpression?: KvsQueryOperation, pageKey?: string): Promise<QpqPagedData<Item>>;

package/lib/esm/logic/dynamo/scan.js

@@ -1,24 +1,24 @@
-import { DynamoDBClient, ScanCommand } from '@aws-sdk/client-dynamodb';
-import { createAwsClient } from '../createAwsClient';
-import { itemsToQpqPagedData } from './utils/itemsToQpqPagedData';
-import { convertDynamoMapToObject } from './convertObjectToDynamoMap';
-import { stringToLastEvaluatedKey } from './logs';
-import { buildDynamoQueryExpression, buildExpressionAttributeNames, buildExpressionAttributeValues } from './qpqDynamoOrm';
-export async function scan(tableName, region, filterExpression, pageKey) {
-    // Instantiate DynamoDB client
-    const dynamoDBClient = createAwsClient(DynamoDBClient, { region });
-    const params = {
-        TableName: tableName,
-        FilterExpression: buildDynamoQueryExpression(filterExpression),
-        ExpressionAttributeValues: filterExpression && buildExpressionAttributeValues([filterExpression]),
-        ExpressionAttributeNames: filterExpression && buildExpressionAttributeNames([filterExpression]),
-    };
-    if (pageKey) {
-        params.ExclusiveStartKey = stringToLastEvaluatedKey(pageKey);
-    }
-    // Create ScanCommand
-    const command = new ScanCommand(params);
-    // TODO: Catch errors and throw QPQ ones
-    const data = await dynamoDBClient.send(command);
-    return itemsToQpqPagedData((data.Items?.map((i) => convertDynamoMapToObject(i)) || []), data.LastEvaluatedKey);
-}
+import { DynamoDBClient, ScanCommand } from '@aws-sdk/client-dynamodb';
+import { createAwsClient } from '../createAwsClient';
+import { itemsToQpqPagedData } from './utils/itemsToQpqPagedData';
+import { convertDynamoMapToObject } from './convertObjectToDynamoMap';
+import { stringToLastEvaluatedKey } from './logs';
+import { buildDynamoQueryExpression, buildExpressionAttributeNames, buildExpressionAttributeValues } from './qpqDynamoOrm';
+export async function scan(tableName, region, filterExpression, pageKey) {
+    // Instantiate DynamoDB client
+    const dynamoDBClient = createAwsClient(DynamoDBClient, { region });
+    const params = {
+        TableName: tableName,
+        FilterExpression: buildDynamoQueryExpression(filterExpression),
+        ExpressionAttributeValues: filterExpression && buildExpressionAttributeValues([filterExpression]),
+        ExpressionAttributeNames: filterExpression && buildExpressionAttributeNames([filterExpression]),
+    };
+    if (pageKey) {
+        params.ExclusiveStartKey = stringToLastEvaluatedKey(pageKey);
+    }
+    // Create ScanCommand
+    const command = new ScanCommand(params);
+    // TODO: Catch errors and throw QPQ ones
+    const data = await dynamoDBClient.send(command);
+    return itemsToQpqPagedData((data.Items?.map((i) => convertDynamoMapToObject(i)) || []), data.LastEvaluatedKey);
+}

package/lib/esm/logic/dynamo/updateItem.d.ts

@@ -1,2 +1,2 @@
-import { KvsCoreDataType, KvsUpdate } from 'quidproquo-core';
-export declare function updateItem<Item>(tableName: string, region: string, update: KvsUpdate, keyName: string, key: KvsCoreDataType, sortkeyName?: string, sortKey?: KvsCoreDataType): Promise<Item>;
+import { KvsCoreDataType, KvsUpdate } from 'quidproquo-core';
+export declare function updateItem<Item>(tableName: string, region: string, update: KvsUpdate, keyName: string, key: KvsCoreDataType, sortkeyName?: string, sortKey?: KvsCoreDataType): Promise<Item>;

package/lib/esm/logic/dynamo/updateItem.js

@@ -1,22 +1,22 @@
-import { DynamoDBClient, ReturnValue, UpdateItemCommand } from '@aws-sdk/client-dynamodb';
-import { createAwsClient } from '../createAwsClient';
-import { convertDynamoMapToObject } from './convertObjectToDynamoMap';
-import { buildAttributeValue, buildDynamoUpdateExpression, buildUpdateExpressionAttributeNames, buildUpdateExpressionAttributeValues, } from './qpqDynamoOrm';
-export async function updateItem(tableName, region, update, keyName, key, sortkeyName, sortKey) {
-    const dynamoDBClient = createAwsClient(DynamoDBClient, { region });
-    const params = {
-        TableName: tableName,
-        Key: {
-            [keyName]: buildAttributeValue(key),
-        },
-        UpdateExpression: buildDynamoUpdateExpression(update),
-        ExpressionAttributeValues: buildUpdateExpressionAttributeValues(update),
-        ExpressionAttributeNames: buildUpdateExpressionAttributeNames(update),
-        ReturnValues: ReturnValue.ALL_NEW,
-    };
-    if (sortkeyName && sortKey !== undefined) {
-        params.Key[sortkeyName] = buildAttributeValue(sortKey);
-    }
-    const result = await dynamoDBClient.send(new UpdateItemCommand(params));
-    return convertDynamoMapToObject(result.Attributes);
-}
+import { DynamoDBClient, ReturnValue, UpdateItemCommand } from '@aws-sdk/client-dynamodb';
+import { createAwsClient } from '../createAwsClient';
+import { convertDynamoMapToObject } from './convertObjectToDynamoMap';
+import { buildAttributeValue, buildDynamoUpdateExpression, buildUpdateExpressionAttributeNames, buildUpdateExpressionAttributeValues, } from './qpqDynamoOrm';
+export async function updateItem(tableName, region, update, keyName, key, sortkeyName, sortKey) {
+    const dynamoDBClient = createAwsClient(DynamoDBClient, { region });
+    const params = {
+        TableName: tableName,
+        Key: {
+            [keyName]: buildAttributeValue(key),
+        },
+        UpdateExpression: buildDynamoUpdateExpression(update),
+        ExpressionAttributeValues: buildUpdateExpressionAttributeValues(update),
+        ExpressionAttributeNames: buildUpdateExpressionAttributeNames(update),
+        ReturnValues: ReturnValue.ALL_NEW,
+    };
+    if (sortkeyName && sortKey !== undefined) {
+        params.Key[sortkeyName] = buildAttributeValue(sortKey);
+    }
+    const result = await dynamoDBClient.send(new UpdateItemCommand(params));
+    return convertDynamoMapToObject(result.Attributes);
+}

package/lib/esm/logic/dynamo/utils/itemsToQpqPagedData.d.ts

@@ -1,2 +1,2 @@
-import { QpqPagedData } from 'quidproquo-core';
-export declare const itemsToQpqPagedData: <T>(items: T[], lastEvaluatedKey?: any) => QpqPagedData<T>;
+import { QpqPagedData } from 'quidproquo-core';
+export declare const itemsToQpqPagedData: <T>(items: T[], lastEvaluatedKey?: any) => QpqPagedData<T>;

package/lib/esm/logic/dynamo/utils/itemsToQpqPagedData.js

@@ -1,5 +1,5 @@
-import { lastEvaluatedKeyToString } from '../logs';
-export const itemsToQpqPagedData = (items, lastEvaluatedKey) => ({
-    items,
-    nextPageKey: lastEvaluatedKey ? lastEvaluatedKeyToString(lastEvaluatedKey) : undefined,
-});
+import { lastEvaluatedKeyToString } from '../logs';
+export const itemsToQpqPagedData = (items, lastEvaluatedKey) => ({
+    items,
+    nextPageKey: lastEvaluatedKey ? lastEvaluatedKeyToString(lastEvaluatedKey) : undefined,
+});

package/lib/esm/logic/dynamo/utils/qpqPagedDataToItems.d.ts

@@ -1,4 +1,4 @@
-export declare const itemsToQpqPagedData: <T>(items: T[], lastEvaluatedKey?: string) => {
-    items: T[];
-    lastEvaluatedKey: "" | Record<string, import("@aws-sdk/client-dynamodb").AttributeValue> | undefined;
-};
+export declare const itemsToQpqPagedData: <T>(items: T[], lastEvaluatedKey?: string) => {
+    items: T[];
+    lastEvaluatedKey: "" | Record<string, import("@aws-sdk/client-dynamodb").AttributeValue> | undefined;
+};

package/lib/esm/logic/dynamo/utils/qpqPagedDataToItems.js

@@ -1,5 +1,5 @@
-import { stringToLastEvaluatedKey } from '../logs';
-export const itemsToQpqPagedData = (items, lastEvaluatedKey) => ({
-    items,
-    lastEvaluatedKey: lastEvaluatedKey && stringToLastEvaluatedKey(lastEvaluatedKey),
-});
+import { stringToLastEvaluatedKey } from '../logs';
+export const itemsToQpqPagedData = (items, lastEvaluatedKey) => ({
+    items,
+    lastEvaluatedKey: lastEvaluatedKey && stringToLastEvaluatedKey(lastEvaluatedKey),
+});

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

@@ -1 +1 @@
-export * from './cognito';
+export * from './cognito';

package/lib/esm/logic/index.js

@@ -1 +1 @@
-export * from './cognito';
+export * from './cognito';

package/lib/esm/logic/lambda/executeLambdaByName.d.ts

@@ -1 +1 @@
-export declare const executeLambdaByName: <R>(functionName: string, region: string, payload: any, isAsync: boolean) => Promise<R | undefined>;
+export declare const executeLambdaByName: <R>(functionName: string, region: string, payload: any, isAsync: boolean) => Promise<R | undefined>;

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

@@ -1,25 +1,25 @@
-import { InvokeCommand, LambdaClient } 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;
-};
+import { InvokeCommand, LambdaClient } 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/neptune/getNeptuneEndpoints.d.ts

@@ -1,2 +1,2 @@
-import { GraphDatabaseEndpoints } from '../../getActionProcessor/core/graphDatabase/customActions/actions';
-export declare const getNeptuneEndpoints: (clusterIdentifier: string, region: string) => Promise<GraphDatabaseEndpoints>;
+import { GraphDatabaseEndpoints } from '../../getActionProcessor/core/graphDatabase/customActions/actions';
+export declare const getNeptuneEndpoints: (clusterIdentifier: string, region: string) => Promise<GraphDatabaseEndpoints>;

package/lib/esm/logic/neptune/getNeptuneEndpoints.js

@@ -1,22 +1,22 @@
-import { DescribeDBClustersCommand, NeptuneClient } from '@aws-sdk/client-neptune';
-import { createAwsClient } from '../createAwsClient';
-export const getNeptuneEndpoints = async (clusterIdentifier, region) => {
-    const neptuneClient = createAwsClient(NeptuneClient, { region });
-    const command = new DescribeDBClustersCommand({
-        DBClusterIdentifier: clusterIdentifier,
-    });
-    try {
-        const response = await neptuneClient.send(command);
-        if (response.DBClusters && response.DBClusters.length > 0) {
-            const cluster = response.DBClusters[0];
-            const writeEndpoint = cluster.Endpoint && cluster.Port ? `https://${cluster.Endpoint}:${cluster.Port}` : undefined;
-            const readEndpoint = cluster.ReaderEndpoint && cluster.Port ? `https://${cluster.ReaderEndpoint}:${cluster.Port}` : undefined;
-            return { writeEndpoint, readEndpoint };
-        }
-        return {};
-    }
-    catch (error) {
-        console.error('Error fetching Neptune cluster endpoints:', error);
-        throw new Error(`Failed to retrieve Neptune endpoints: ${error}`);
-    }
-};
+import { DescribeDBClustersCommand, NeptuneClient } from '@aws-sdk/client-neptune';
+import { createAwsClient } from '../createAwsClient';
+export const getNeptuneEndpoints = async (clusterIdentifier, region) => {
+    const neptuneClient = createAwsClient(NeptuneClient, { region });
+    const command = new DescribeDBClustersCommand({
+        DBClusterIdentifier: clusterIdentifier,
+    });
+    try {
+        const response = await neptuneClient.send(command);
+        if (response.DBClusters && response.DBClusters.length > 0) {
+            const cluster = response.DBClusters[0];
+            const writeEndpoint = cluster.Endpoint && cluster.Port ? `https://${cluster.Endpoint}:${cluster.Port}` : undefined;
+            const readEndpoint = cluster.ReaderEndpoint && cluster.Port ? `https://${cluster.ReaderEndpoint}:${cluster.Port}` : undefined;
+            return { writeEndpoint, readEndpoint };
+        }
+        return {};
+    }
+    catch (error) {
+        console.error('Error fetching Neptune cluster endpoints:', error);
+        throw new Error(`Failed to retrieve Neptune endpoints: ${error}`);
+    }
+};

package/lib/esm/logic/neptune/index.d.ts

@@ -1 +1 @@
-export * from './getNeptuneEndpoints';
+export * from './getNeptuneEndpoints';

package/lib/esm/logic/neptune/index.js

@@ -1 +1 @@
-export * from './getNeptuneEndpoints';
+export * from './getNeptuneEndpoints';

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

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

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

@@ -1,10 +1,10 @@
-import { GetParameterCommand, SSMClient } 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);
+import { GetParameterCommand, SSMClient } 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

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

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

@@ -1,11 +1,11 @@
-import { GetParametersCommand, SSMClient } 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);
+import { GetParametersCommand, SSMClient } 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

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

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

@@ -1,11 +1,11 @@
-import { ParameterType, PutParameterCommand, SSMClient } 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,
-    }));
-};
+import { ParameterType, PutParameterCommand, SSMClient } 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

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

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

@@ -1,14 +1,14 @@
-import { DeleteObjectsCommand, S3Client } 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 || '');
-};
+import { DeleteObjectsCommand, S3Client } 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

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

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

@@ -1,21 +1,21 @@
-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;
-    }
-};
+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/getObjectStorageClass.d.ts

@@ -1 +1 @@
-export declare const getObjectStorageClass: (bucketName: string, key: string, region: string) => Promise<'cold_storage' | 'standard'>;
+export declare const getObjectStorageClass: (bucketName: string, key: string, region: string) => Promise<"cold_storage" | "standard">;

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

@@ -1,26 +1,26 @@
-import { HeadObjectCommand, S3Client } from '@aws-sdk/client-s3';
-import { createAwsClient } from '../createAwsClient';
-export const getObjectStorageClass = async (bucketName, key, region) => {
-    const s3Client = createAwsClient(S3Client, { region });
-    const response = await s3Client.send(new HeadObjectCommand({
-        Key: key,
-        Bucket: bucketName,
-    }));
-    // Map AWS StorageClass to our custom labels
-    switch (response.StorageClass) {
-        case 'GLACIER':
-        case 'GLACIER_IR':
-        case 'DEEP_ARCHIVE':
-        case 'ONEZONE_IA':
-        case 'EXPRESS_ONEZONE':
-        case 'OUTPOSTS':
-        case 'SNOW':
-            return 'cold_storage';
-        case 'STANDARD_IA':
-        case 'STANDARD':
-        case 'INTELLIGENT_TIERING':
-        case 'REDUCED_REDUNDANCY':
-        default:
-            return 'standard';
-    }
-};
+import { HeadObjectCommand, S3Client } from '@aws-sdk/client-s3';
+import { createAwsClient } from '../createAwsClient';
+export const getObjectStorageClass = async (bucketName, key, region) => {
+    const s3Client = createAwsClient(S3Client, { region });
+    const response = await s3Client.send(new HeadObjectCommand({
+        Key: key,
+        Bucket: bucketName,
+    }));
+    // Map AWS StorageClass to our custom labels
+    switch (response.StorageClass) {
+        case 'GLACIER':
+        case 'GLACIER_IR':
+        case 'DEEP_ARCHIVE':
+        case 'ONEZONE_IA':
+        case 'EXPRESS_ONEZONE':
+        case 'OUTPOSTS':
+        case 'SNOW':
+            return 'cold_storage';
+        case 'STANDARD_IA':
+        case 'STANDARD':
+        case 'INTELLIGENT_TIERING':
+        case 'REDUCED_REDUNDANCY':
+        default:
+            return 'standard';
+    }
+};