post-app.test.ts

import 'mocha';
import { expect } from 'chai';

import { PostApp } from '../../src/apps/post-app';
import { TodoItem } from '../../src/models/todo-item';
import { TodoRepository } from '../../src/models/todo-repository';
import { ApiGatewayResponse } from '../../src/models/apigateway/apigateway-response';
import { ApiGatewayEventMock } from '../models/apigateway-event-mock';

describe('PostApp instance', () => {

    describe('constructor', () => {

        it('table is assigned', async () => {
            const tableName = 'MY_TABLE';

            let invoked = false;
            const putItem = function(todoItem: TodoItem, table: string): Promise<void> {
                return new Promise<void>((resolve, reject) => {
                    invoked = true;
                    resolve();
                });
            };
            
            const event = new ApiGatewayEventMock();
            const repo: TodoRepository = { putTodo: putItem };
            const app = new PostApp(tableName, repo);
            
            const response: ApiGatewayResponse = await app.run(event);
            
            expect(invoked).to.equal(true);
        });
    });
});

post-app.ts

import { ApiGatewayEvent } from '../models/apigateway/apigateway-event';
import { ApiGatewayResponse } from '../models/apigateway/apigateway-response';

import { TodoRepository } from '../models/todo-repository';
import { TodoItem } from '../models/todo-item';

export class PostApp {
    table: string;
    repository: TodoRepository;
    
    constructor(table: string, repository: TodoRepository) {
        this.table = table;
        this.repository = repository;
    }
    
    async run(event: ApiGatewayEvent): Promise<ApiGatewayResponse> {
        
        try {
            const todo: TodoItem = JSON.parse(event.body);
            
            if (!todo.title) {
                return { statusCode: 422 };
            } else if (!todo.isComplete) {
                todo.isComplete = false;
            } else if (!todo.id) {
                return { statusCode: 422 };
            }
            
            await this.repository.putTodo(todo, this.table);
            return { statusCode: 201, body: todo };
            
        } catch(err) {
            console.log(err);
            return { statusCode: 500 };
        }
    }
}

post-handler.ts

import { ApiGatewayEvent } from '../models/apigateway/apigateway-event';
import { ApiGatewayResponse } from '../models/apigateway/apigateway-response';
import { PostApp } from '../apps/post-app';
import { TodoDynamoClientRepository } from '../models/todo-dynamoclient-repository';

export const handler = async (event: ApiGatewayEvent): Promise<ApiGatewayResponse> => {
    if (!process.env['SAMPLE_TABLE']) {
        return { statusCode: 500 };
    }
    
    const table: string = process.env['SAMPLE_TABLE'];
    const repository = new TodoDynamoClientRepository();
    
    const app = new PostApp(table, repository);
    return await app.run(event);
};

todo-dynamoclient-repository.ts

import { DynamoDB } from 'aws-sdk';

import { TodoItem } from './todo-item';
import { TodoRepository } from './todo-repository';

export class TodoDynamoClientRepository implements TodoRepository {
    docClient: DynamoDB.DocumentClient;
    
    constructor() {
        this.docClient = new DynamoDB.DocumentClient();
    }
    
    async putTodo(todoItem: TodoItem, table: string): Promise<void> {

        const params: DynamoDB.DocumentClient.PutItemInput = {
            TableName: table,
            Item: todoItem
        };
        
        await this.docClient.put(params).promise();
        return;
    }
}

todo-repository.ts

import { TodoItem } from './todo-item';

export interface TodoRepository {
    putTodo(todoItem: TodoItem, table: string): Promise<void>;
}