quidproquo-actionprocessor-awslambda 0.0.30 → 0.0.31

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/index.ts

@@ -0,0 +1,7 @@
+export { default as getConfigGetSecretActionProcessor } from './config/getConfigGetSecretActionProcessor';
+export { default as getConfigGetParameterActionProcessor } from './config/getConfigGetParameterActionProcessor';
+export { default as getConfigGetParametersActionProcessor } from './config/getConfigGetParametersActionProcessor';
+export { default as getAPIGatewayEventActionProcessor } from './event/getAPIGatewayEventActionProcessor';
+export { default as getEventBridgeEventActionProcessor } from './event/getEventBridgeEventActionProcessor';
+export { default as getSystemActionProcessor } from './system';
+export { default as getFileActionProcessor } from './file';

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/src/getActionProcessor/index.ts

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

package/src/index.ts

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

package/src/lambdas/index.ts

@@ -0,0 +1,4 @@
+export * from './lambdaConfig';
+
+export * from './lambdaAPIGatewayEvent';
+export * from './lambdaEventBridgeEvent';

package/src/lambdas/lambdaAPIGatewayEvent.ts

@@ -0,0 +1,105 @@
+import { APIGatewayEvent, Context } from 'aws-lambda';
+import { qpqWebServerUtils } from 'quidproquo-webserver';
+import { createRuntime, askProcessEvent, ErrorTypeEnum } from 'quidproquo-core';
+import { coreActionProcessor, webserverActionProcessor } from 'quidproquo-actionprocessor-node';
+
+import { DynamicModuleLoader } from '../types/DynamicLoader';
+import * as awsLambdaUtils from '../awsLambdaUtils';
+import {
+  getAPIGatewayEventActionProcessor,
+  getSystemActionProcessor,
+  getFileActionProcessor,
+  getConfigGetSecretActionProcessor,
+  getConfigGetParameterActionProcessor,
+  getConfigGetParametersActionProcessor,
+} from '../getActionProcessor';
+
+import { lambdaRuntimeConfig, ActionProcessorListResolver } from './lambdaConfig';
+
+// @ts-ignore - Special webpack loader
+import qpqDynamicModuleLoader from 'qpq-dynamic-loader!';
+
+// TODO: Make this a util or something based on server time or something..
+const getDateNow = () => new Date().toISOString();
+
+const ErrorTypeHttpResponseMap = {
+  [ErrorTypeEnum.BadRequest]: 400,
+  [ErrorTypeEnum.Unauthorized]: 401,
+  [ErrorTypeEnum.PaymentRequired]: 402,
+  [ErrorTypeEnum.Forbidden]: 403,
+  [ErrorTypeEnum.NotFound]: 404,
+  [ErrorTypeEnum.TimeOut]: 408,
+  [ErrorTypeEnum.UnsupportedMediaType]: 415,
+  [ErrorTypeEnum.OutOfResources]: 500,
+  [ErrorTypeEnum.GenericError]: 500,
+  [ErrorTypeEnum.NotImplemented]: 501,
+  [ErrorTypeEnum.NoContent]: 204,
+  [ErrorTypeEnum.Invalid]: 422,
+};
+
+export const getAPIGatewayEventExecutor = (
+  dynamicModuleLoader: DynamicModuleLoader,
+  getCustomActionProcessors: ActionProcessorListResolver = () => ({}),
+) => {
+  return async (event: APIGatewayEvent, context: Context) => {
+    // Build a processor for the session and stuff
+    // Remove the non route ones ~ let the story execute action add them
+    const storyActionProcessor = {
+      ...coreActionProcessor,
+      ...webserverActionProcessor,
+
+      ...getAPIGatewayEventActionProcessor(lambdaRuntimeConfig.qpqConfig),
+      ...getConfigGetSecretActionProcessor(lambdaRuntimeConfig),
+      ...getConfigGetParameterActionProcessor(lambdaRuntimeConfig),
+      ...getConfigGetParametersActionProcessor(lambdaRuntimeConfig),
+      ...getSystemActionProcessor(dynamicModuleLoader),
+      ...getFileActionProcessor(lambdaRuntimeConfig),
+
+      ...getCustomActionProcessors(lambdaRuntimeConfig),
+    };
+
+    const logger = async (result: any) => {
+      // addResult(
+      //   envConfig.appName,
+      //   getDateNow(),
+      //   doWeCarePath,
+      //   "route-infrastructure",
+      //   "infrastructure",
+      //   "askRoute",
+      //   result
+      // );
+    };
+
+    //   // Run the callback
+
+    const resolveStory = createRuntime(
+      {},
+      storyActionProcessor,
+      getDateNow,
+      logger,
+      awsLambdaUtils.randomGuid,
+    );
+
+    const result = await resolveStory(askProcessEvent, [event, context]);
+
+    // Run the callback
+    if (!result.error) {
+      return {
+        statusCode: result.result.statusCode,
+        body: JSON.stringify(result.result.body),
+        headers: result.result.headers,
+      };
+    }
+
+    console.log(JSON.stringify(result));
+    const code = ErrorTypeHttpResponseMap[result.error.errorType];
+    return {
+      statusCode: code || 500,
+      body: JSON.stringify(result.error),
+      headers: qpqWebServerUtils.getCorsHeaders(lambdaRuntimeConfig.qpqConfig, {}, event.headers),
+    };
+  };
+};
+
+// Default executor
+export const executeAPIGatewayEvent = getAPIGatewayEventExecutor(qpqDynamicModuleLoader);

package/src/lambdas/lambdaConfig.ts

@@ -0,0 +1,11 @@
+import { ActionProcessorList } from 'quidproquo-core';
+
+import { QPQAWSLambdaConfig } from '../runtimeConfig/QPQAWSLambdaConfig';
+
+export const lambdaRuntimeConfig = JSON.parse(
+  process.env.lambdaRuntimeConfig || '{}',
+) as QPQAWSLambdaConfig;
+
+export type ActionProcessorListResolver = (
+  lambdaRuntimeConfig: QPQAWSLambdaConfig,
+) => ActionProcessorList;

package/src/lambdas/lambdaEventBridgeEvent.ts

@@ -0,0 +1,60 @@
+import { EventBridgeEvent, Context } from 'aws-lambda';
+import { createRuntime, askProcessEvent } from 'quidproquo-core';
+import { coreActionProcessor, webserverActionProcessor } from 'quidproquo-actionprocessor-node';
+
+import { DynamicModuleLoader } from '../types/DynamicLoader';
+import * as awsLambdaUtils from '../awsLambdaUtils';
+import {
+  getEventBridgeEventActionProcessor,
+  getSystemActionProcessor,
+  getFileActionProcessor,
+  getConfigGetSecretActionProcessor,
+  getConfigGetParameterActionProcessor,
+  getConfigGetParametersActionProcessor,
+} from '../getActionProcessor';
+
+import { lambdaRuntimeConfig, ActionProcessorListResolver } from './lambdaConfig';
+
+// @ts-ignore - Special webpack loader
+import qpqDynamicModuleLoader from 'qpq-dynamic-loader!';
+
+// TODO: Make this a util or something based on server time or something..
+const getDateNow = () => new Date().toISOString();
+
+export const getEventBridgeEventExecutor = (
+  dynamicModuleLoader: DynamicModuleLoader,
+  getCustomActionProcessors: ActionProcessorListResolver = () => ({}),
+) => {
+  return async (event: EventBridgeEvent<string, void>, context: Context) => {
+    // Build a processor for the session and stuff
+    // Remove the  non event ones
+    const storyActionProcessor = {
+      ...coreActionProcessor,
+      ...webserverActionProcessor,
+
+      ...getEventBridgeEventActionProcessor(lambdaRuntimeConfig),
+      ...getSystemActionProcessor(dynamicModuleLoader),
+      ...getFileActionProcessor(lambdaRuntimeConfig),
+      ...getConfigGetSecretActionProcessor(lambdaRuntimeConfig),
+      ...getConfigGetParameterActionProcessor(lambdaRuntimeConfig),
+      ...getConfigGetParametersActionProcessor(lambdaRuntimeConfig),
+
+      ...getCustomActionProcessors(lambdaRuntimeConfig),
+    };
+
+    const logger = async (result: any) => {};
+
+    // Run the callback
+    const resolveStory = createRuntime(
+      {},
+      storyActionProcessor,
+      getDateNow,
+      logger,
+      awsLambdaUtils.randomGuid,
+    );
+
+    await resolveStory(askProcessEvent, [event, context]);
+  };
+};
+
+export const executeEventBridgeEvent = getEventBridgeEventExecutor(qpqDynamicModuleLoader);

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,
+  };
+};

package/src/logic/s3/objectExists.ts

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

package/src/logic/s3/readTextFile.ts

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

package/src/logic/s3/s3Client.ts

@@ -0,0 +1,5 @@
+import { S3Client } from '@aws-sdk/client-s3';
+
+const s3Client = new S3Client({ region: 'ap-southeast-2' });
+
+export default s3Client;

package/src/logic/s3/s3Utils.ts

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

package/src/logic/s3/writeTextFile.ts

@@ -0,0 +1,17 @@
+import { PutObjectCommand } from '@aws-sdk/client-s3';
+
+import s3Client from './s3Client';
+
+export const writeTextFile = async (
+  bucketName: string,
+  key: string,
+  data: string,
+): Promise<void> => {
+  await s3Client.send(
+    new PutObjectCommand({
+      Key: key,
+      Bucket: bucketName,
+      Body: Buffer.from(data),
+    }),
+  );
+};