quidproquo-actionprocessor-awslambda 0.0.35 → 0.0.36

package/package.json

@@ -1,12 +1,9 @@
 {
   "name": "quidproquo-actionprocessor-awslambda",
-  "version": "0.0.35",
+  "version": "0.0.36",
   "description": "",
   "main": "./lib/index.js",
   "types": "./lib/index.d.js",
-  "files": [
-    "lib/**/*"
-  ],
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
     "clean": "npx rimraf lib",

package/src/awsLambdaUtils.ts

@@ -0,0 +1,22 @@
+import { randomUUID } from 'crypto';
+import { match } from 'node-match-path';
+
+export const randomGuid = () => {
+  return randomUUID();
+};
+
+export interface UrlMatch {
+  didMatch: boolean;
+  params: Record<string, string> | null;
+}
+
+export const matchUrl = (path: string, url: string): UrlMatch => {
+  // /attempt/{attemptUuid}/result/{test} => /attempt/:attemptUuid/result/:test
+  const modifiedPath = path.replaceAll(/{(.+?)}/g, (m, g) => `:${g}`);
+
+  const matchResult = match(modifiedPath, url);
+  return {
+    didMatch: matchResult.matches,
+    params: matchResult.params,
+  };
+};

package/src/getActionProcessor/core/config/getConfigGetParameterActionProcessor.ts

@@ -0,0 +1,23 @@
+import { ConfigActionType, ConfigGetParameterActionProcessor, actionResult } from 'quidproquo-core';
+
+import { QPQAWSLambdaConfig } from '../../../runtimeConfig/QPQAWSLambdaConfig';
+import { resolveParameterKey } from '../../../runtimeConfig/qpqAwsLambdaRuntimeConfigUtils';
+
+import { getParameter } from '../../../logic/parametersManager/getParameter';
+
+const getProcessConfigGetParameter = (
+  runtimeConfig: QPQAWSLambdaConfig,
+): ConfigGetParameterActionProcessor => {
+  return async ({ parameterName }) => {
+    const awsParameterKey = resolveParameterKey(parameterName, runtimeConfig);
+    const parameterValue = await getParameter(awsParameterKey);
+
+    return actionResult(parameterValue);
+  };
+};
+
+export default (runtimeConfig: QPQAWSLambdaConfig) => {
+  return {
+    [ConfigActionType.GetParameter]: getProcessConfigGetParameter(runtimeConfig),
+  };
+};

package/src/getActionProcessor/core/config/getConfigGetParametersActionProcessor.ts

@@ -0,0 +1,27 @@
+import {
+  ConfigActionType,
+  ConfigGetParametersActionProcessor,
+  actionResult,
+} from 'quidproquo-core';
+
+import { QPQAWSLambdaConfig } from '../../../runtimeConfig/QPQAWSLambdaConfig';
+import { resolveParameterKey } from '../../../runtimeConfig/qpqAwsLambdaRuntimeConfigUtils';
+
+import { getParameters } from '../../../logic/parametersManager/getParameters';
+
+const getProcessConfigGetParameters = (
+  runtimeConfig: QPQAWSLambdaConfig,
+): ConfigGetParametersActionProcessor => {
+  return async ({ parameterNames }) => {
+    const awsParameterKeys = parameterNames.map((pn) => resolveParameterKey(pn, runtimeConfig));
+    const parameterValues = await getParameters(awsParameterKeys);
+
+    return actionResult(parameterValues);
+  };
+};
+
+export default (runtimeConfig: QPQAWSLambdaConfig) => {
+  return {
+    [ConfigActionType.GetParameters]: getProcessConfigGetParameters(runtimeConfig),
+  };
+};

package/src/getActionProcessor/core/config/getConfigGetSecretActionProcessor.ts

@@ -0,0 +1,23 @@
+import { ConfigActionType, ConfigGetSecretActionProcessor, actionResult } from 'quidproquo-core';
+
+import { QPQAWSLambdaConfig } from '../../../runtimeConfig/QPQAWSLambdaConfig';
+import { resolveSecretKey } from '../../../runtimeConfig/qpqAwsLambdaRuntimeConfigUtils';
+
+import { getSecret } from '../../../logic/secretsManager/getSecret';
+
+const getProcessConfigActionType = (
+  runtimeConfig: QPQAWSLambdaConfig,
+): ConfigGetSecretActionProcessor => {
+  return async ({ secretName }) => {
+    const awsSecretKey = resolveSecretKey(secretName, runtimeConfig);
+    const secretValue = await getSecret(awsSecretKey);
+
+    return actionResult(secretValue);
+  };
+};
+
+export default (runtimeConfig: QPQAWSLambdaConfig) => {
+  return {
+    [ConfigActionType.GetSecret]: getProcessConfigActionType(runtimeConfig),
+  };
+};

package/src/getActionProcessor/core/config/index.ts

@@ -0,0 +1,11 @@
+import { QPQAWSLambdaConfig } from '../../../runtimeConfig/QPQAWSLambdaConfig';
+
+import getConfigGetParameterActionProcessor from './getConfigGetParameterActionProcessor';
+import getConfigGetParametersActionProcessor from './getConfigGetParametersActionProcessor';
+import getConfigGetSecretActionProcessor from './getConfigGetSecretActionProcessor';
+
+export default (runtimeConfig: QPQAWSLambdaConfig) => ({
+  ...getConfigGetParameterActionProcessor(runtimeConfig),
+  ...getConfigGetParametersActionProcessor(runtimeConfig),
+  ...getConfigGetSecretActionProcessor(runtimeConfig),
+});

package/src/getActionProcessor/core/event/getAPIGatewayEventActionProcessor.ts

@@ -0,0 +1,134 @@
+import {
+  EventActionType,
+  QPQConfig,
+  qpqCoreUtils,
+  MatchStoryResult,
+  EventMatchStoryActionProcessor,
+  EventTransformEventParamsActionProcessor,
+  EventTransformResponseResultActionProcessor,
+  EventAutoRespondActionProcessor,
+  actionResult,
+  actionResultError,
+  ErrorTypeEnum,
+} from 'quidproquo-core';
+
+import {
+  RouteQPQWebServerConfigSetting,
+  HTTPEventParams,
+  qpqWebServerUtils,
+} from 'quidproquo-webserver';
+
+import { APIGatewayEvent, Context, APIGatewayProxyResult } from 'aws-lambda';
+
+import { matchUrl } from '../../../awsLambdaUtils';
+
+const getProcessTransformEventParams = (
+  appName: string,
+): EventTransformEventParamsActionProcessor<[APIGatewayEvent, Context], HTTPEventParams<any>> => {
+  return async ({ eventParams: [apiGatewayEvent, context] }) => {
+    const path = (apiGatewayEvent.path || '').replace(new RegExp(`^(\/${appName})/`), '/');
+    console.log('getProcessTransformEventParams', JSON.stringify(apiGatewayEvent));
+
+    return actionResult({
+      path,
+      query: {
+        ...(apiGatewayEvent.multiValueQueryStringParameters || {}),
+        ...(apiGatewayEvent.queryStringParameters || {}),
+      } as { [key: string]: undefined | string | string[] },
+      body: apiGatewayEvent.body ? JSON.parse(apiGatewayEvent.body) : undefined,
+      headers: apiGatewayEvent.headers,
+      method: apiGatewayEvent.httpMethod as 'GET' | 'POST',
+      correlation: context.awsRequestId,
+      sourceIp: apiGatewayEvent.requestContext.identity.sourceIp,
+    });
+  };
+};
+
+const getProcessTransformResponseResult = (
+  configs: QPQConfig,
+): EventTransformResponseResultActionProcessor<APIGatewayProxyResult> => {
+  // We might need to JSON.stringify the body.
+  return async (payload) => {
+    // Validate response
+    // if !valid actionResultError
+
+    console.log('getProcessTransformResponseResult', JSON.stringify(payload));
+
+    return actionResult<APIGatewayProxyResult>({
+      statusCode: payload.response.result.statusCode,
+      body: payload.response.result.body,
+      headers: {
+        'Content-Type': 'application/json',
+        ...qpqWebServerUtils.getCorsHeaders(configs, {}, payload.transformedEventParams.headers),
+        ...(payload.response.headers || {}),
+      },
+    });
+  };
+};
+
+const getProcessAutoRespond = (
+  configs: QPQConfig,
+): EventAutoRespondActionProcessor<HTTPEventParams<any>> => {
+  return async (payload) => {
+    if (payload.transformedEventParams.method === 'OPTIONS') {
+      return actionResult({
+        result: {
+          statusCode: 200,
+          headers: qpqWebServerUtils.getCorsHeaders(
+            configs,
+            {},
+            payload.transformedEventParams.headers,
+          ),
+        },
+      });
+    }
+
+    return actionResult(null);
+  };
+};
+
+const getProcessMatchStory = (
+  routes: RouteQPQWebServerConfigSetting[],
+): EventMatchStoryActionProcessor<HTTPEventParams<any>> => {
+  return async (payload) => {
+    // Sort the routes by string length
+    // Note: We may need to filter variable routes out {} as the variables are length independent
+    const sortedRoutes = routes
+      .filter((r: any) => r.method === payload.transformedEventParams.method)
+      .sort((a: any, b: any) => {
+        if (a.path.length < b.path.length) return -1;
+        if (a.path.length > b.path.length) return 1;
+        return 0;
+      });
+
+    // Find the most relevant match
+    const matchedRoute = sortedRoutes
+      .map((r) => ({
+        match: matchUrl(r.path, payload.transformedEventParams.path),
+        route: r,
+      }))
+      .find((m) => m.match.didMatch);
+
+    if (!matchedRoute) {
+      return actionResultError(ErrorTypeEnum.NotFound, 'route not found');
+    }
+
+    return actionResult<MatchStoryResult>({
+      src: matchedRoute.route.src,
+      runtime: matchedRoute.route.runtime,
+      options: matchedRoute.match.params || {},
+    });
+  };
+};
+
+export default (config: QPQConfig) => {
+  const routes = qpqWebServerUtils.getAllRoutes(config);
+  const appName = qpqCoreUtils.getAppName(config);
+
+  return {
+    [EventActionType.TransformEventParams]: getProcessTransformEventParams(appName),
+    [EventActionType.TransformResponseResult]: getProcessTransformResponseResult(config),
+    [EventActionType.AutoRespond]: getProcessAutoRespond(config),
+    [EventActionType.MatchStory]: getProcessMatchStory(routes),
+  };
+};

package/src/getActionProcessor/core/event/getEventBridgeEventActionProcessor.ts

@@ -0,0 +1,66 @@
+import {
+  EventActionType,
+  MatchStoryResult,
+  EventMatchStoryActionProcessor,
+  EventTransformEventParamsActionProcessor,
+  EventTransformResponseResultActionProcessor,
+  EventAutoRespondActionProcessor,
+  actionResult,
+  actionResultError,
+  ErrorTypeEnum,
+  ScheduledEventParams,
+} from 'quidproquo-core';
+
+import { QPQAWSLambdaConfig, LambdaRuntimeConfig } from '../../../runtimeConfig/QPQAWSLambdaConfig';
+
+import { EventBridgeEvent, Context, APIGatewayProxyResult } from 'aws-lambda';
+
+const getProcessTransformEventParams = (): EventTransformEventParamsActionProcessor<
+  [EventBridgeEvent<any, any>, Context],
+  ScheduledEventParams<any>
+> => {
+  return async ({ eventParams: [eventBridgeEvent, context] }) => {
+    return actionResult({
+      time: eventBridgeEvent.time,
+      correlation: context.awsRequestId,
+      detail: eventBridgeEvent.detail,
+    });
+  };
+};
+
+// No transform
+const getProcessTransformResponseResult = (): EventTransformResponseResultActionProcessor<any> => {
+  return async ({ response }) => actionResult<any>(response);
+};
+
+// never early exit (maybe add validation?)
+const getProcessAutoRespond = (): EventAutoRespondActionProcessor<ScheduledEventParams<any>> => {
+  return async () => actionResult(null);
+};
+
+const getProcessMatchStory = (
+  lambdaRuntimeConfig?: LambdaRuntimeConfig,
+): EventMatchStoryActionProcessor<ScheduledEventParams<any>> => {
+  return async (payload) => {
+    console.log('Trying to match story');
+    console.log(JSON.stringify(lambdaRuntimeConfig));
+    if (!lambdaRuntimeConfig) {
+      return actionResultError(ErrorTypeEnum.NotFound, 'event runtime not found');
+    }
+
+    return actionResult<MatchStoryResult>({
+      src: lambdaRuntimeConfig.src,
+      runtime: lambdaRuntimeConfig.runtime,
+      options: {},
+    });
+  };
+};
+
+export default (runtimeConfig: QPQAWSLambdaConfig) => {
+  return {
+    [EventActionType.TransformEventParams]: getProcessTransformEventParams(),
+    [EventActionType.TransformResponseResult]: getProcessTransformResponseResult(),
+    [EventActionType.AutoRespond]: getProcessAutoRespond(),
+    [EventActionType.MatchStory]: getProcessMatchStory(runtimeConfig.lambdaRuntimeConfig),
+  };
+};

package/src/getActionProcessor/core/file/getFileDeleteActionProcessor.ts

@@ -0,0 +1,31 @@
+import { QPQAWSLambdaConfig } from '../../../runtimeConfig/QPQAWSLambdaConfig';
+import { resolveResourceName } from '../../../runtimeConfig/qpqAwsLambdaRuntimeConfigUtils';
+import {
+  FileDeleteActionProcessor,
+  actionResult,
+  actionResultError,
+  FileActionType,
+  ErrorTypeEnum,
+} from 'quidproquo-core';
+import { deleteFiles } from '../../../logic/s3/s3Utils';
+
+const getProcessFileDelete = (runtimeConfig: QPQAWSLambdaConfig): FileDeleteActionProcessor => {
+  return async ({ drive, filepaths }) => {
+    const s3BucketName = resolveResourceName(drive, runtimeConfig);
+    const errored = await deleteFiles(s3BucketName, filepaths);
+
+    // errored deletes are a graceful success ~ Retry
+    // if (errored.length > 0) {
+    //   return actionResultError(
+    //     ErrorTypeEnum.GenericError,
+    //     `Could not delete files ${errored.length}`,
+    //   );
+    // }
+
+    return actionResult(errored);
+  };
+};
+
+export default (runtimeConfig: QPQAWSLambdaConfig) => ({
+  [FileActionType.Delete]: getProcessFileDelete(runtimeConfig),
+});

package/src/getActionProcessor/core/file/getFileExistsActionProcessor.ts

@@ -0,0 +1,16 @@
+import { QPQAWSLambdaConfig } from '../../../runtimeConfig/QPQAWSLambdaConfig';
+import { resolveResourceName } from '../../../runtimeConfig/qpqAwsLambdaRuntimeConfigUtils';
+import { FileExistsActionProcessor, actionResult, FileActionType } from 'quidproquo-core';
+import { objectExists } from '../../../logic/s3/s3Utils';
+
+const getProcessFileExists = (runtimeConfig: QPQAWSLambdaConfig): FileExistsActionProcessor => {
+  return async ({ drive, filepath }) => {
+    const s3BucketName = resolveResourceName(drive, runtimeConfig);
+
+    return actionResult(await objectExists(s3BucketName, filepath));
+  };
+};
+
+export default (runtimeConfig: QPQAWSLambdaConfig) => ({
+  [FileActionType.Exists]: getProcessFileExists(runtimeConfig),
+});

package/src/getActionProcessor/core/file/getFileListDirectoryActionProcessor.ts

@@ -0,0 +1,28 @@
+import { QPQAWSLambdaConfig } from '../../../runtimeConfig/QPQAWSLambdaConfig';
+import { resolveResourceName } from '../../../runtimeConfig/qpqAwsLambdaRuntimeConfigUtils';
+import { FileListDirectoryActionProcessor, actionResult, FileActionType } from 'quidproquo-core';
+import { listFiles } from '../../../logic/s3/s3Utils';
+
+const getProcessFileListDirectory = (
+  runtimeConfig: QPQAWSLambdaConfig,
+): FileListDirectoryActionProcessor => {
+  return async ({ drive, folderPath, maxFiles, pageToken }) => {
+    const s3BucketName = resolveResourceName(drive, runtimeConfig);
+    const s3FileList = await listFiles(s3BucketName, folderPath, maxFiles, pageToken);
+
+    // Add the drive onto the list
+    const fileInfos = s3FileList.fileInfos.map((s3fi) => ({
+      ...s3fi,
+      drive: drive,
+    }));
+
+    return actionResult({
+      fileInfos,
+      pageToken: s3FileList.pageToken,
+    });
+  };
+};
+
+export default (runtimeConfig: QPQAWSLambdaConfig) => ({
+  [FileActionType.ListDirectory]: getProcessFileListDirectory(runtimeConfig),
+});

package/src/getActionProcessor/core/file/getFileReadTextContentsActionProcessor.ts

@@ -0,0 +1,18 @@
+import { QPQAWSLambdaConfig } from '../../../runtimeConfig/QPQAWSLambdaConfig';
+import { resolveResourceName } from '../../../runtimeConfig/qpqAwsLambdaRuntimeConfigUtils';
+import { FileReadTextContentsActionProcessor, actionResult, FileActionType } from 'quidproquo-core';
+import { readTextFile } from '../../../logic/s3/s3Utils';
+
+const getProcessFileReadTextContents = (
+  runtimeConfig: QPQAWSLambdaConfig,
+): FileReadTextContentsActionProcessor => {
+  return async ({ drive, filepath }) => {
+    const s3BucketName = resolveResourceName(drive, runtimeConfig);
+
+    return actionResult(await readTextFile(s3BucketName, filepath));
+  };
+};
+
+export default (runtimeConfig: QPQAWSLambdaConfig) => ({
+  [FileActionType.ReadTextContents]: getProcessFileReadTextContents(runtimeConfig),
+});

package/src/getActionProcessor/core/file/getFileWriteTextContentsActionProcessor.ts

@@ -0,0 +1,23 @@
+import { QPQAWSLambdaConfig } from '../../../runtimeConfig/QPQAWSLambdaConfig';
+import { resolveResourceName } from '../../../runtimeConfig/qpqAwsLambdaRuntimeConfigUtils';
+import {
+  FileWriteTextContentsActionProcessor,
+  actionResult,
+  FileActionType,
+} from 'quidproquo-core';
+import { writeTextFile } from '../../../logic/s3/s3Utils';
+
+const getProcessFileWriteTextContents = (
+  runtimeConfig: QPQAWSLambdaConfig,
+): FileWriteTextContentsActionProcessor => {
+  return async ({ drive, filepath, data }) => {
+    const s3BucketName = resolveResourceName(drive, runtimeConfig);
+    await writeTextFile(s3BucketName, filepath, data);
+
+    return actionResult(void 0);
+  };
+};
+
+export default (runtimeConfig: QPQAWSLambdaConfig) => ({
+  [FileActionType.WriteTextContents]: getProcessFileWriteTextContents(runtimeConfig),
+});

package/src/getActionProcessor/core/file/index.ts

@@ -0,0 +1,15 @@
+import { QPQAWSLambdaConfig } from '../../../runtimeConfig/QPQAWSLambdaConfig';
+
+import getFileDeleteActionProcessor from './getFileDeleteActionProcessor';
+import getFileExistsActionProcessor from './getFileExistsActionProcessor';
+import getFileListDirectoryActionProcessor from './getFileListDirectoryActionProcessor';
+import getFileReadTextContentsActionProcessor from './getFileReadTextContentsActionProcessor';
+import getFileWriteTextContentsActionProcessor from './getFileWriteTextContentsActionProcessor';
+
+export default (runtimeConfig: QPQAWSLambdaConfig) => ({
+  ...getFileDeleteActionProcessor(runtimeConfig),
+  ...getFileExistsActionProcessor(runtimeConfig),
+  ...getFileListDirectoryActionProcessor(runtimeConfig),
+  ...getFileReadTextContentsActionProcessor(runtimeConfig),
+  ...getFileWriteTextContentsActionProcessor(runtimeConfig),
+});

package/src/getActionProcessor/core/system/getExecuteStoryActionProcessor.ts

@@ -0,0 +1,67 @@
+import {
+  SystemActionType,
+  QPQConfig,
+  qpqCoreUtils,
+  SystemExecuteStoryActionPayload,
+  StorySession,
+  createRuntime,
+  SystemExecuteStoryActionProcessor,
+  actionResultError,
+  ErrorTypeEnum,
+  actionResult,
+  ActionProcessorList,
+} from 'quidproquo-core';
+
+import { randomGuid } from './../../../awsLambdaUtils';
+import { DynamicModuleLoader } from '../../../types/DynamicLoader';
+
+export const getDateNow = () => new Date().toISOString();
+
+const getProcessExecuteStory = <T extends Array<any>>(
+  dynamicModuleLoader: DynamicModuleLoader,
+): SystemExecuteStoryActionProcessor<T> => {
+  return async (
+    payload: SystemExecuteStoryActionPayload<T>,
+    session: StorySession,
+    actionProcessors: ActionProcessorList,
+  ): Promise<any> => {
+    let module = await dynamicModuleLoader(payload.src);
+    if (module === null) {
+      return actionResultError(ErrorTypeEnum.NotFound, `Module not found [${payload.src}]`);
+    }
+
+    const story = module[payload.runtime];
+    if (!story) {
+      return actionResultError(
+        ErrorTypeEnum.NotFound,
+        `[${payload.runtime}] not found in module [${payload.src}]`,
+      );
+    }
+
+    const logger = async (result: any) => {
+      // return await addResult(service, getDateNow(), payload.params[0][0].path, 'user-route', payload.src, payload.runtime, result);
+    };
+
+    const resolveStory = createRuntime(session, actionProcessors, getDateNow, logger, randomGuid);
+    const storyResult = await resolveStory(story, payload.params);
+
+    if (storyResult.error) {
+      return actionResultError(
+        storyResult.error.errorType,
+        `story error! in ${payload.src}::${payload.runtime} -> [${storyResult.error.errorText}]`,
+        storyResult.error.errorStack,
+      );
+    }
+
+    return actionResult({
+      result: storyResult.result,
+      session: storyResult.session,
+    });
+  };
+};
+
+export default (dynamicModuleLoader: DynamicModuleLoader) => {
+  return {
+    [SystemActionType.ExecuteStory]: getProcessExecuteStory(dynamicModuleLoader),
+  };
+};

package/src/getActionProcessor/core/system/index.ts

@@ -0,0 +1,6 @@
+import getExecuteStoryActionProcessor from './getExecuteStoryActionProcessor';
+import { DynamicModuleLoader } from '../../../types/DynamicLoader';
+
+export default (dynamicModuleLoader: DynamicModuleLoader) => ({
+  ...getExecuteStoryActionProcessor(dynamicModuleLoader),
+});

package/{lib/index.d.ts → src/index.ts}

@@ -1,4 +1,6 @@
 export * from './getActionProcessor';
 export * as awsLambdaUtils from './awsLambdaUtils';
+
 export * from './runtimeConfig/QPQAWSLambdaConfig';
+
 export * from './types/DynamicLoader';

package/src/logic/parametersManager/getParameter.ts

@@ -0,0 +1,13 @@
+import { SSMClient, GetParameterCommand } from '@aws-sdk/client-ssm';
+
+const smClient = new SSMClient({});
+
+export const getParameter = async (parameterName: string): Promise<string> => {
+  const response = await smClient.send(
+    new GetParameterCommand({
+      Name: parameterName,
+    }),
+  );
+
+  return response.Parameter?.Value || '';
+};

package/src/logic/parametersManager/getParameters.ts

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

package/src/logic/s3/deleteFiles.ts

@@ -0,0 +1,17 @@
+import { DeleteObjectsCommand, DeleteObjectsCommandInput } from '@aws-sdk/client-s3';
+
+import s3Client from './s3Client';
+
+export const deleteFiles = async (drive: string, filepaths: string[]): Promise<string[]> => {
+  const bucketParams: DeleteObjectsCommandInput = {
+    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/src/logic/s3/listFiles.ts

@@ -0,0 +1,66 @@
+import { ListObjectsV2Command, ListObjectsV2CommandInput } from '@aws-sdk/client-s3';
+import { filePathDelimiter } from 'quidproquo-core';
+import s3Client from './s3Client';
+
+export interface S3FileInfo {
+  filepath: string;
+  isDir: boolean;
+  hashMd5?: string;
+}
+
+export interface S3FileList {
+  fileInfos: S3FileInfo[];
+  pageToken?: string;
+}
+
+export const listFiles = async (
+  drive: string,
+  folder: string = '',
+  maxKeys: number = 1000,
+  pageToken?: string,
+): Promise<S3FileList> => {
+  const validatedPrefix = `${folder}${
+    folder.endsWith(filePathDelimiter) || !folder ? '' : filePathDelimiter
+  }`;
+  const bucketParams: ListObjectsV2CommandInput = {
+    Bucket: drive,
+    Delimiter: filePathDelimiter,
+    Prefix: validatedPrefix,
+    ContinuationToken: pageToken,
+    MaxKeys: maxKeys,
+  };
+
+  // Declare truncated as a flag that the while loop is based on.
+  let files: S3FileInfo[] = [];
+
+  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: drive,
+        isDir: true,
+      })),
+    ];
+  }
+
+  files = [
+    ...files,
+    ...(response.Contents || [])
+      .filter((c) => !!c.Key && c.Key != folder)
+      .map(
+        (item): S3FileInfo => ({
+          filepath: item.Key!,
+          isDir: item.Key!.endsWith(filePathDelimiter),
+          hashMd5: item.ETag,
+        }),
+      ),
+  ];
+
+  return {
+    fileInfos: files,
+    pageToken: response.NextContinuationToken,
+  };
+};