add builder and serializer to base resource model

Author: eduardomourar

src/callback.ts

@@ -1,15 +1,13 @@
 import { v4 as uuidv4 } from 'uuid';
 import CloudFormation from 'aws-sdk/clients/cloudformation';
 
-import {
-    SessionProxy,
-} from './proxy';
-import { BaseResourceModel, OperationStatus, Response } from './interface';
+import { SessionProxy } from './proxy';
+import { BaseResourceModel, CfnResponse, OperationStatus } from './interface';
 
 
-const LOG = console;
+const LOGGER = console;
 
-interface ProgressOptions extends Response<BaseResourceModel> {
+interface ProgressOptions extends CfnResponse<BaseResourceModel> {
     session: SessionProxy,
     currentOperationStatus?: OperationStatus,
 }
@@ -46,6 +44,6 @@ export async function reportProgress(options: ProgressOptions): Promise<void> {
         if (response['ResponseMetadata']) {
             requestId = response.ResponseMetadata.RequestId;
         }
-        LOG.info(`Record Handler Progress with Request Id ${requestId} and Request: ${request}`);
+        LOGGER.debug(`Record Handler Progress with Request Id ${requestId} and Request: ${JSON.stringify(request)}`);    
     }
 }

src/interface.ts

@@ -3,6 +3,8 @@ import {
     LogicalResourceId,
     NextToken,
 } from 'aws-sdk/clients/cloudformation';
+import { allArgsConstructor, builder } from 'tombok';
+
 
 export type Optional<T> = T | undefined | null;
 
@@ -11,46 +13,46 @@ export interface Callable<R extends Array<any>, T> {
 }
 
 export enum Action {
-    Create = "CREATE",
-    Read = "READ",
-    Update = "UPDATE",
-    Delete = "DELETE",
-    List = "LIST",
+    Create = 'CREATE',
+    Read = 'READ',
+    Update = 'UPDATE',
+    Delete = 'DELETE',
+    List = 'LIST',
 }
 
 export enum StandardUnit {
-    Count = "Count",
-    Milliseconds = "Milliseconds",
+    Count = 'Count',
+    Milliseconds = 'Milliseconds',
 }
 
 export enum MetricTypes {
-    HandlerException = "HandlerException",
-    HandlerInvocationCount = "HandlerInvocationCount",
-    HandlerInvocationDuration = "HandlerInvocationDuration",
+    HandlerException = 'HandlerException',
+    HandlerInvocationCount = 'HandlerInvocationCount',
+    HandlerInvocationDuration = 'HandlerInvocationDuration',
 }
 
 export enum OperationStatus {
-    Pending = "PENDING",
-    InProgress = "IN_PROGRESS",
-    Success = "SUCCESS",
-    Failed = "FAILED",
+    Pending = 'PENDING',
+    InProgress = 'IN_PROGRESS',
+    Success = 'SUCCESS',
+    Failed = 'FAILED',
 }
 
 export enum HandlerErrorCode {
-    NotUpdatable = "NotUpdatable",
-    InvalidRequest = "InvalidRequest",
-    AccessDenied = "AccessDenied",
-    InvalidCredentials = "InvalidCredentials",
-    AlreadyExists = "AlreadyExists",
-    NotFound = "NotFound",
-    ResourceConflict = "ResourceConflict",
-    Throttling = "Throttling",
-    ServiceLimitExceeded = "ServiceLimitExceeded",
-    NotStabilized = "NotStabilized",
-    GeneralServiceException = "GeneralServiceException",
-    ServiceInternalError = "ServiceInternalError",
-    NetworkFailure = "NetworkFailure",
-    InternalFailure = "InternalFailure",
+    NotUpdatable = 'NotUpdatable',
+    InvalidRequest = 'InvalidRequest',
+    AccessDenied = 'AccessDenied',
+    InvalidCredentials = 'InvalidCredentials',
+    AlreadyExists = 'AlreadyExists',
+    NotFound = 'NotFound',
+    ResourceConflict = 'ResourceConflict',
+    Throttling = 'Throttling',
+    ServiceLimitExceeded = 'ServiceLimitExceeded',
+    NotStabilized = 'NotStabilized',
+    GeneralServiceException = 'GeneralServiceException',
+    ServiceInternalError = 'ServiceInternalError',
+    NetworkFailure = 'NetworkFailure',
+    InternalFailure = 'InternalFailure',
 }
 
 export interface Credentials {
@@ -59,27 +61,59 @@ export interface Credentials {
     sessionToken: string;
 }
 
-export interface RequestContext<CallbackT> {
+export interface RequestContext<T> {
     invocation: number;
-    callbackContext: CallbackT;
+    callbackContext: T;
     cloudWatchEventsRuleName: string;
     cloudWatchEventsTargetId: string;
 }
 
-export interface BaseResourceModel {
-    serialize(): Map<string, any>;
-    deserialize(): BaseResourceModel;
+@builder
+@allArgsConstructor
+export class BaseResourceModel {
+    ['constructor']: typeof BaseResourceModel;
+    protected static readonly TYPE_NAME?: string;
+
+    constructor(...args: any[]) {}
+    public static builder() {}
+
+    public getTypeName(): string {
+        return Object.getPrototypeOf(this).constructor.TYPE_NAME;
+    }
+
+    public serialize(): Map<string, any> {
+        const data: Map<string, any> = new Map<string, any>(Object.entries(this));
+        data.forEach((value: any, key: string) => {
+            if (value == null) {
+                data.delete(key);
+            }
+        });
+        return data;
+    }
+
+    public static deserialize(jsonData: Object): ThisType<BaseResourceModel> {
+        return new this(new Map<string, any>(Object.entries(jsonData)));
+    }
+
+    public toObject(): Object {
+        // @ts-ignore
+        const obj = Object.fromEntries(this.serialize().entries());
+        return obj;
+    }
 }
 
-export interface BaseResourceHandlerRequest<T extends BaseResourceModel> {
-    clientRequestToken: ClientRequestToken;
-    desiredResourceState?: T;
-    previousResourceState?: T;
-    logicalResourceIdentifier?: LogicalResourceId;
-    nextToken?: NextToken;
+@allArgsConstructor
+export class BaseResourceHandlerRequest<T extends BaseResourceModel> {
+    public clientRequestToken: ClientRequestToken;
+    public desiredResourceState?: T;
+    public previousResourceState?: T;
+    public logicalResourceIdentifier?: LogicalResourceId;
+    public nextToken?: NextToken;
+
+    constructor(...args: any[]) {}
 }
 
-export interface Response<T> {
+export interface CfnResponse<T> {
     bearerToken: string;
     errorCode?: HandlerErrorCode;
     operationStatus: OperationStatus;

src/utils.ts

@@ -137,3 +137,30 @@ export interface LambdaContext {
     invokedFunctionArn: string;
     getRemainingTimeInMillis(): number;
 }
+
+/**
+ * Returns an ordinary object using the Map's keys as the object's keys and its values as the object's values.
+ *
+ * @throws {Error} Since object keys are evaluated as strings (in particular, `{ [myObj]: value }` will have a key named
+ *                 `[Object object]`), it's possible that two keys within the Map may evaluate to the same object key.
+ *                 In this case, if the associated values are not the same, throws an Error.
+ */
+Map.prototype.toObject = function(): Object {
+    let o: any = {};
+    for (let [key, value] of this.entries()) {
+        if (o.hasOwnProperty(key) && o[key] !== value) {
+            throw new Error(`Duplicate key ${key} found in Map. First value: ${o[key]}, next value: ${value}`);
+        }
+
+        o[key] = value;
+    }
+
+    return o;
+};
+
+/**
+ * Defines the default JSON representation of a Map to be an array of key-value pairs.
+ */
+Map.prototype.toJSON = function<K, V>(this: Map<K, V>): Array<[K, V]> {
+    return Array.from(this.entries());
+};

tests/lib/interface.test.ts

@@ -0,0 +1,45 @@
+import {
+    BaseResourceModel,
+    Optional,
+} from '../../src/interface';
+
+
+describe('when getting interface', () => {
+
+    class ResourceModel extends BaseResourceModel {
+        ['constructor']: typeof ResourceModel;
+        public static readonly TYPE_NAME: string = 'Test::Resource::Model';
+
+        public somekey: Optional<string>;
+        public someotherkey: Optional<string>;
+    }
+
+    test('base resource model get type name', () => {
+        const model = new ResourceModel();
+        expect(model.getTypeName()).toBe(model.constructor.TYPE_NAME);
+    });
+
+    test('base resource model deserialize', () => {
+        expect(() => ResourceModel.deserialize(null)).toThrow('Cannot convert undefined or null to object');
+    });
+
+    test('base resource model serialize', () => {
+        const model = new ResourceModel(new Map(Object.entries({
+            somekey: 'a', someotherkey: null
+        })));
+        const serialized = model.serialize();
+        expect(serialized.size).toBe(1);
+        expect(serialized.get('someotherkey')).not.toBeDefined();
+    });
+
+    test('base resource model to object', () => {
+        const model = new ResourceModel(new Map(Object.entries({
+            somekey: 'a', someotherkey: 'b'
+        })));
+        const obj = model.toObject();
+        expect(obj).toMatchObject({
+            somekey: 'a',
+            someotherkey: 'b',
+        });
+    });
+});