add success method to progress class

Author: eduardomourar

src/proxy.ts

@@ -1,67 +1,19 @@
-import { AWSError, CredentialProviderChain, Request, Service } from 'aws-sdk';
 import { ConfigurationOptions } from 'aws-sdk/lib/config';
-import { Credentials, CredentialsOptions } from 'aws-sdk/lib/credentials';
-import { ServiceConfigurationOptions } from 'aws-sdk/lib/service';
+import { CredentialsOptions } from 'aws-sdk/lib/credentials';
 import * as Aws from 'aws-sdk/clients/all';
 import { NextToken } from 'aws-sdk/clients/cloudformation';
 import { allArgsConstructor, builder, IBuilder} from 'tombok';
 
 import {
     BaseResourceHandlerRequest,
     BaseResourceModel,
-    Callable,
     HandlerErrorCode,
-    Newable,
     OperationStatus,
 } from './interface';
 
 
 type ClientMap = typeof Aws;
 type Client = InstanceType<ClientMap[keyof ClientMap]>;
-type ClientType<T = ClientMap> = T[keyof T] extends Service ? never : T[keyof T];
-
-// type Async<T> = T extends AsyncGenerator<infer R> ? AsyncGenerator<R> : T extends Generator<infer R> ? AsyncGenerator<R> : T extends Promise<infer R> ? Promise<R> : Promise<T>;
-
-// type ProxyModule<M> = {
-//     [K in keyof M]: M[K] extends (...args: infer A) => infer R ? (...args: A) => Async<R> : never;
-// };
-
-// type Callback<D> = (err: AWSError | undefined, data: D) => void;
-
-// interface AWSRequestMethod<P, D> {
-//     (params: P, callback?: Callback<D>): Request<D, AWSError>;
-//     (callback?: Callback<D>): Request<D, AWSError>;
-// }
-
-// export type CapturedAWSClient<C extends AWSClient> = {
-//     [K in keyof C]: C[K] extends AWSRequestMethod<infer P, infer D>
-//       ? AWSRequestMethod<P, D>
-//       : C[K];
-//   };
-
-//   export type CapturedAWS<T = ClientMap> = {
-//     [K in keyof T]: T[K] extends AWSClient ? CapturedAWSClient<T[K]> : T[K];
-//   };
-
-//   export function captureAWSClient<C extends AWSClient>(
-//     client: C
-//   ): CapturedAWSClient<C>;
-//   export function captureAWS(awssdk: ClientMap): CapturedAWS;
-
-// type Clients = { [K in keyof AwsClientMap]?: AwsClientMap[K] extends Service ? never : AwsClientMap[K] };
-
-class SessionCredentialsProvider {
-
-    private awsSessionCredentials: Credentials;
-
-    public get(): Credentials {
-        return this.awsSessionCredentials;
-    }
-
-    public setCredentials(credentials: CredentialsOptions): void {
-        this.awsSessionCredentials = new Credentials(credentials);
-    }
-}
 
 export class SessionProxy {
 
@@ -75,37 +27,7 @@ export class SessionProxy {
             ...this.options,
             ...options,
         });
-        return service; //this.promisifyReturn(service);
-    }
-
-    // private createService<T extends ClientMap, K extends keyof T>(client: Newable<T[K]>, options: ServiceConfigurationOptions): InstanceType<ClientType> {
-    //     // const clients: { [K in keyof ClientMap]?: ClientMap[K] } = Aws;
-    //     // const name: T;
-
-    //     return new client();
-    // }
-
-    // Wraps an Aws endpoint instance so that you don’t always have to chain `.promise()` onto every function
-    public promisifyReturn(obj: any): ProxyConstructor {
-        return new Proxy(obj, {
-            get(target, propertyKey) {
-                const property = target[propertyKey];
-
-                if (typeof property === "function") {
-                    return function (...args: any[]) {
-                        const result = property.apply(this, args);
-
-                        if (result instanceof Request) {
-                            return result.promise();
-                        } else {
-                            return result;
-                        }
-                    }
-                } else {
-                    return property;
-                }
-            },
-        });
+        return service;
     }
 
     public static getSession(credentials?: CredentialsOptions, region?: string): SessionProxy | null {
@@ -152,7 +74,7 @@ export class ProgressEvent<R extends BaseResourceModel = BaseResourceModel, T =
      * A callback will be scheduled with an initial delay of no less than the number
      * of seconds specified in the progress event.
      */
-    public callbackDelaySeconds: number;
+    public callbackDelaySeconds: number = 0;
 
     /**
      * The output resource instance populated by a READ for synchronous results and
@@ -176,7 +98,6 @@ export class ProgressEvent<R extends BaseResourceModel = BaseResourceModel, T =
 
     public serialize(
         toTesponse: boolean = false, bearerToken?: string
-    // ): Record<string, any> {
     ): Map<string, any> {
         // To match Java serialization, which drops `null` values, and the
         // contract tests currently expect this also.
@@ -226,14 +147,33 @@ export class ProgressEvent<R extends BaseResourceModel = BaseResourceModel, T =
     /**
      * Convenience method for constructing IN_PROGRESS response
      */
-    public static progress(model: any, cxt: any): ProgressEvent {
-        const event = ProgressEvent.builder()
-            .callbackContext(cxt)
-            .resourceModel(model)
-            .status(OperationStatus.InProgress)
-            .build();
+    public static progress(model?: any, ctx?: any): ProgressEvent {
+        const progress = ProgressEvent.builder()
+            .status(OperationStatus.InProgress);
+        if (ctx) {
+            progress.callbackContext(ctx);
+        }
+        if (model) {
+            progress.resourceModel(model);
+        }
+        const event = progress.build();
+        return event;
+    }
+
+    /**
+     * Convenience method for constructing a SUCCESS response
+     */
+    public static success(model?: any, ctx?: any): ProgressEvent {
+        const event = ProgressEvent.progress(model, ctx);
+        event.status = OperationStatus.Success;
         return event;
     }
+
+    public toObject(): Object {
+        // @ts-ignore
+        const obj: Object = Object.fromEntries(this.serialize().entries());
+        return obj;
+    }
 }
 
 /**

tests/lib/proxy.test.ts

@@ -14,33 +14,12 @@ describe('when getting session proxy', () => {
 
     const BEARER_TOKEN: string = 'f3390613-b2b5-4c31-a4c6-66813dff96a6';
 
-    @builder
-    @allArgsConstructor
-    class ResourceModel extends Map<string, any> implements BaseResourceModel {
-    
-        public static typeName: string = 'Test::Resource::Model';
-    
+    class ResourceModel extends BaseResourceModel {
+
+        public static readonly TYPE_NAME: string = 'Test::Resource::Model';
+
         public somekey: Optional<string>;
         public someotherkey: Optional<string>;
-    
-        constructor(...args: any[]) {super()}
-        public static builder(template?: Partial<ResourceModel>): IBuilder<ResourceModel> {return null}
-    
-        serialize(): Map<string, any> {
-            const data: Map<string, any> = new Map<string, any>(Object.entries(JSON.parse(JSON.stringify(this))));
-            data.forEach((value: any, key: string) => {
-                if (value == null) {
-                    data.delete(key);
-                }
-            });
-            return data;
-        }
-        deserialize(): ResourceModel {return <ResourceModel>undefined}
-        toObject(): Object {
-            // @ts-ignore
-            const obj = Object.fromEntries(this.serialize().entries());
-            return obj;
-        }
     }
 
     test('get session returns proxy', () => {
@@ -69,14 +48,14 @@ describe('when getting session proxy', () => {
             status: OperationStatus.Failed,
             errorCode: errorCode,
             message,
-            // callbackDelaySeconds: 0,
+            callbackDelaySeconds: 0,
         })));
     });
 
     test('progress event serialize to response with context', () => {
         const message: string = 'message of event with context';
         const event = ProgressEvent.builder()
-            .callbackContext({ "a": "b" })
+            .callbackContext({ a: 'b' })
             .message(message)
             .status(OperationStatus.Success)
             .build();
@@ -91,7 +70,8 @@ describe('when getting session proxy', () => {
     test('progress event serialize to response with model', () => {
         const message = 'message of event with model';
         const model = new ResourceModel(new Map(Object.entries({
-            "somekey": "a", "someotherkey": "b"
+            somekey: 'a',
+            someotherkey: 'b',
         })));
         const event = new ProgressEvent(new Map(Object.entries({
             status: OperationStatus.Success,
@@ -103,17 +83,22 @@ describe('when getting session proxy', () => {
             operationStatus: OperationStatus.Success,
             message,
             bearerToken: BEARER_TOKEN,
-            resourceModel: {"somekey": "a", "someotherkey": "b"},
+            resourceModel: {
+                somekey: 'a',
+                someotherkey: 'b',
+            },
         })));
     });
 
     test('progress event serialize to response with models', () => {
         const message = 'message of event with models';
         const models = [new ResourceModel(new Map(Object.entries({
-            "somekey": "a", "someotherkey": "b"
+            somekey: 'a',
+            someotherkey: 'b',
         }))),
         new ResourceModel(new Map(Object.entries({
-            "somekey": "c", "someotherkey": "d"
+            somekey: 'c',
+            someotherkey: 'd',
         })))];
         const event = new ProgressEvent(new Map(Object.entries({
             status: OperationStatus.Success,
@@ -126,8 +111,14 @@ describe('when getting session proxy', () => {
             message,
             bearerToken: BEARER_TOKEN,
             resourceModels: [
-                {"somekey": "a", "someotherkey": "b"},
-                {"somekey": "c", "someotherkey": "d"},
+                {
+                    somekey: 'a',
+                    someotherkey: 'b',
+                },
+                {
+                    somekey: 'c',
+                    someotherkey: 'd',
+                },
             ],
         })));
     });