[Serverless] Refactoring: Using Ports and Adapters pattern to refactor code

时间：2021-05-27 11:41:36 阅读：33 评论：0 收藏：0 [点我收藏+]

The original code:

createGroup.ts:

import { v4 as uuidv4 } from "uuid";
import "source-map-support/register";
import * as AWS from "aws-sdk";
import {
  APIGatewayProxyEvent,
  APIGatewayProxyHandler,
  APIGatewayProxyResult,
} from "aws-lambda";
import { getUserId } from "../../auth/utils";

const docClient = new AWS.DynamoDB.DocumentClient();
const groupTables = process.env.GROUPS_TABLE;

export const handler: APIGatewayProxyHandler = async (
  event: APIGatewayProxyEvent
): Promise<APIGatewayProxyResult> => {
  console.log("Processing event: ", event);
  const itemId = uuidv4();

  const parsedBody = JSON.parse(event.body);
  const authorization = event.headers.Authorization;
  const splits = authorization.split(" ");
  const jwtToken = splits[1];

  const newItem = {
    id: itemId,
    userId: getUserId(jwtToken),
    ...parsedBody,
  };

  await docClient
    .put({
      TableName: groupTables,
      Item: newItem,
    })
    .promise();

  return {
    statusCode: 201,
    headers: {
      "Access-Control-Allow-Origin": "*",
    },
    body: JSON.stringify({
      newItem,
    }),
  };
};

getGroups.ts:

import * as AWS from "aws-sdk";
import {
  APIGatewayProxyEvent,
  APIGatewayProxyHandler,
  APIGatewayProxyResult,
} from "aws-lambda";

const docClient = new AWS.DynamoDB.DocumentClient();
const groupTables = process.env.GROUPS_TABLE;

export const handler: APIGatewayProxyHandler = async (
  event: APIGatewayProxyEvent
): Promise<APIGatewayProxyResult> => {
  console.log("Processing event: ", event);
  const result = await docClient
    .scan({
      TableName: groupTables,
    })
    .promise();

  const items = result.Items;

  return {
    statusCode: 200,
    headers: {
      "Access-Control-Allow-Origin": "*",
    },
    body: JSON.stringify({
      items,
    }),
  };
};

Tow entry functions both contains busniess logic code and data access code (dynamoDB).

What we want is:

Entry function --> Busniess logic code --> Data access layer

First, create interfaces for both Reqest & Model:

requests/CreateGroupRequest.ts:

export interface CreateGroupRequest {
  name: string;
  description: string;
}

models/Group.ts:

export interface Group {
  id: string;
  name: string;
  description: string;
  userId: string;
}

Then create data access layer code, it mainly handle all the dynamoDB operations.

dataAccess/groupAccess.ts:

import * as AWS from "aws-sdk";
import { DocumentClient } from "aws-sdk/clients/dynamodb";

import {Group} from ‘../models/Group‘

export class GroupAccess {
    constructor(
        private readonly docClient: DocumentClient = new AWS.DynamoDB.DocumentClient();
        private readonly groupsTable = process.env.GROUPS_TABLE
    ) {

    }

    async getAllGroups(): Promise<Group[]> {
        console.log(‘Getting all groups‘);

        const result = await this.docClient.scan({
            TableName: this.groupsTable,
        }).promise()

        const items = result.Items;

        return items as Group[];
    }

    async createGroup(group: Group): Promise<Group> {
        console.log(‘Creating a group with id‘, group.id)

        await this.docClient.put({
            TableName: this.groupsTable,
            Item: group
        }).promise();

        return group;
    }
}

Then create busniessLogic layer, it mainly talk to data access layer and passing and returning the data.

busniessLogic/groups.ts:

import * as uuid from "uuid";

import { Group } from "../models/Group";
import { GroupAccess } from "../dataAccess/groupAccess";
import { CreateGroupRequest } from "../requests/CreateGroupRequest";
import { getUserId } from "../auth/utils";

const groupAccess = new GroupAccess();

export async function getAllGroups(): Promise<Group[]> {
  return groupAccess.getAllGroups();
}

export async function createGroup(
  createGroupRequest: CreateGroupRequest,
  jwtToken: string
) {
  const itemId = uuid.v4();
  const userId = getUserId(jwtToken);

  return await groupAccess.createGroup({
    id: itemId,
    userId: userId,
    name: createGroupRequest.name,
    description: createGroupRequest.description,
  });
}

Lastly, entry function will just talk to busniess layer code:

createGroup.ts:

import "source-map-support/register";
import {
  APIGatewayProxyEvent,
  APIGatewayProxyHandler,
  APIGatewayProxyResult,
} from "aws-lambda";
import { createGroup } from "../../busniessLogic/groups";
import { CreateGroupRequest } from "../../requests/CreateGroupRequest";

export const handler: APIGatewayProxyHandler = async (
  event: APIGatewayProxyEvent
): Promise<APIGatewayProxyResult> => {
  console.log("Processing event: ", event);

  const newGroup: CreateGroupRequest = JSON.parse(event.body);
  const authorization = event.headers.Authorization;
  const splits = authorization.split(" ");
  const jwtToken = splits[1];

  const newItem = await createGroup(newGroup, jwtToken);

  return {
    statusCode: 201,
    headers: {
      "Access-Control-Allow-Origin": "*",
    },
    body: JSON.stringify({
      newItem,
    }),
  };
};

getGroups.ts:

import {
  APIGatewayProxyEvent,
  APIGatewayProxyHandler,
  APIGatewayProxyResult,
} from "aws-lambda";
import { getAllGroups } from "src/busniessLogic/groups";

export const handler: APIGatewayProxyHandler = async (
  event: APIGatewayProxyEvent
): Promise<APIGatewayProxyResult> => {
  console.log("Processing event: ", event);
  const items = await getAllGroups();

  return {
    statusCode: 200,
    headers: {
      "Access-Control-Allow-Origin": "*",
    },
    body: JSON.stringify({
      items,
    }),
  };
};

[Serverless] Refactoring: Using Ports and Adapters pattern to refactor code

原文：https://www.cnblogs.com/Answer1215/p/14815707.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)