feat(idempotency): Add function wrapper and decorator

package.json

@@ -86,4 +86,4 @@
   "dependencies": {
     "hosted-git-info": "^6.1.1"
   }
-}
+}

packages/idempotency/src/Exceptions.ts

@@ -10,8 +10,23 @@ class IdempotencyInvalidStatusError extends Error {
 
 }
 
+class IdempotencyInconsistentStateError extends Error {
+
+}
+
+class IdempotencyAlreadyInProgressError extends Error {
+
+}
+
+class IdempotencyPersistenceLayerError extends Error {
+
+}
+
 export {
   IdempotencyItemNotFoundError,
   IdempotencyItemAlreadyExistsError,
-  IdempotencyInvalidStatusError
+  IdempotencyInvalidStatusError,
+  IdempotencyInconsistentStateError,
+  IdempotencyAlreadyInProgressError,
+  IdempotencyPersistenceLayerError
 };

packages/idempotency/src/IdempotencyHandler.ts

@@ -0,0 +1,39 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { AnyFunctionWithRecord, IdempotencyRecordStatus } from './types';
+import { IdempotencyOptions } from './types/IdempotencyOptions';
+import { IdempotencyRecord } from 'persistence';
+import { IdempotencyInconsistentStateError, IdempotencyItemAlreadyExistsError, IdempotencyAlreadyInProgressError, IdempotencyPersistenceLayerError } from './Exceptions';
+
+export class IdempotencyHandler<U> {
+
+  public constructor(private functiontoMakeIdempotent: AnyFunctionWithRecord<U>, private functionPayloadToBeHashed: unknown, 
+    private idempotencyOptions: IdempotencyOptions, private fullFunctionPayload: Record<string, any>) {}
+
+  public determineResultFromIdempotencyRecord(idempotencyRecord: IdempotencyRecord): Promise<U> | U{ 
+    if (idempotencyRecord.getStatus() === IdempotencyRecordStatus.EXPIRED) {
+      throw new IdempotencyInconsistentStateError();
+    } else if (idempotencyRecord.getStatus() === IdempotencyRecordStatus.INPROGRESS){
+      throw new IdempotencyAlreadyInProgressError(`There is already an execution in progress with idempotency key: ${idempotencyRecord.idempotencyKey}`);
+    } else {
+      // Currently recalling the method as this fulfills FR1. FR3 will address using the previously stored value https://github.com/awslabs/aws-lambda-powertools-typescript/issues/447
+      return this.functiontoMakeIdempotent(this.fullFunctionPayload); 
+    }
+  }
+
+  public async process_idempotency(): Promise<U> {
+    try {
+      await this.idempotencyOptions.persistenceStore.saveInProgress(this.functionPayloadToBeHashed);
+    } catch (e) {
+      if (e instanceof IdempotencyItemAlreadyExistsError) {
+        const idempotencyRecord: IdempotencyRecord = await this.idempotencyOptions.persistenceStore.getRecord(this.functionPayloadToBeHashed);
+
+        return this.determineResultFromIdempotencyRecord(idempotencyRecord);
+      } else {
+        throw new IdempotencyPersistenceLayerError();
+      }
+    }
+
+    return this.functiontoMakeIdempotent(this.fullFunctionPayload);
+  }
+}

packages/idempotency/src/idempotentDecorator.ts

@@ -0,0 +1,19 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { IdempotencyOptions } from './types/IdempotencyOptions';
+import { IdempotencyHandler } from './IdempotencyHandler';
+
+const idempotent = function (options: IdempotencyOptions) {
+  return function (_target: any, _propertyKey: string, descriptor: PropertyDescriptor) {
+    const childFunction = descriptor.value;
+    descriptor.value = function(record: Record<string, any>){
+      const idempotencyHandler: IdempotencyHandler<unknown> = new IdempotencyHandler<unknown>(childFunction, record[options.dataKeywordArgument], options, record);
+
+      return idempotencyHandler.process_idempotency();
+    };
+
+    return descriptor;
+  }; 
+};
+
+export { idempotent };
+

packages/idempotency/src/makeFunctionIdempotent.ts

@@ -1,11 +1,19 @@
-import type { AnyFunction } from './types/AnyFunction';
-import type { IdempotencyOptions } from './types/IdempotencyOptions';
-
-const makeFunctionIdempotent = <U>(
-  fn: AnyFunction<U>,
-  _options: IdempotencyOptions
-  // TODO: revisit this with a more specific type if possible
-  /* eslint-disable @typescript-eslint/no-explicit-any */
-): (...args: Array<any>) => Promise<U | void> => (...args) => fn(...args);
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { AnyFunctionWithRecord, AnyIdempotentFunction } from './types/AnyFunction';
+import { IdempotencyOptions } from './types/IdempotencyOptions';
+import { IdempotencyHandler } from './IdempotencyHandler';
+
+const makeFunctionIdempotent = function <U>(
+  fn: AnyFunctionWithRecord<U>,
+  options: IdempotencyOptions
+): AnyIdempotentFunction<U> {
+  const wrappedFunction: AnyIdempotentFunction<U> = function (record: Record<string, any>): Promise<U> {
+    const idempotencyHandler: IdempotencyHandler<U> = new IdempotencyHandler<U>(fn, record[options.dataKeywordArgument], options, record);
+
+    return idempotencyHandler.process_idempotency();
+  };
+
+  return wrappedFunction;
+};
 
 export { makeFunctionIdempotent };

packages/idempotency/src/types/AnyFunction.ts

@@ -1,6 +1,11 @@
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-type AnyFunction<U> = (...args: Array<any>) => Promise<U>;
+type AnyFunctionWithRecord<U> = (record: Record<string,any>) => Promise<U> | U;
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AnyIdempotentFunction<U> = (record: Record<string,any>) => Promise<U>;
 
 export {
-  AnyFunction
+  // AnyFunction,
+  AnyFunctionWithRecord,
+  AnyIdempotentFunction
 };

packages/idempotency/src/types/index.ts

@@ -1,3 +1,4 @@
 export * from './AnyFunction';
 export * from './IdempotencyRecordStatus';
-export * from './PersistenceLayer';
+export * from './IdempotencyRecordOptions';
+export * from './PersistenceLayer';

packages/idempotency/tests/helpers/populateEnvironmentVariables.ts

@@ -6,4 +6,4 @@ process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE = '128';
 if (process.env.AWS_REGION === undefined && process.env.CDK_DEFAULT_REGION === undefined) {
   process.env.AWS_REGION = 'eu-west-1';
 }
-process.env._HANDLER = 'index.handler';
+process.env._HANDLER = 'index.handler';