Fathomminds\Rest\Database\DynamoDb\Resource

Complexity

Total Complexity

35

Size/Duplication

Total Lines	194
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

100%

Importance

Changes	5
Bugs	0	Features	0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	3
A	createClient()	0	11	2
A	getFullDatabaseName()	0	4	1
A	get()	0	7	2
A	getOne()	0	6	1
A	createGetQuery()	0	8	1
A	getAll()	0	6	1
A	createScanQuery()	0	7	1
A	post()	0	12	3
A	createPostQuery()	0	10	1
A	createPutQuery()	0	10	1
A	delete()	0	10	3
A	createDeleteQuery()	0	8	1
A	marshalItem()	0	4	1
A	unmarshalItem()	0	7	2
A	unmarshalBatch()	0	11	3
A	throwAwsPostError()	0	11	2
A	throwAwsPutError()	0	11	2
A	put()	0	13	4

<?php
namespace Fathomminds\Rest\Database\DynamoDb;

use Aws\Sdk;
use Aws\DynamoDb\DynamoDbClient as Client;
use Aws\DynamoDb\Marshaler;
use Fathomminds\Rest\Exceptions\RestException;
use Fathomminds\Rest\Contracts\IResource;
use Fathomminds\Rest\Helpers\Uuid;
use Aws\DynamoDb\Exception\DynamoDbException;

class Resource implements IResource
{
    protected $client;
    protected $databaseName;
    protected $collection;
    protected $fullTableName;
    protected $resourceName;
    protected $primaryKey;
    protected $marshaler;

    public function __construct($resourceName, $primaryKey, Client $client = null, $databaseName = null)
    {
        $this->resourceName = $resourceName;
        $this->primaryKey = $primaryKey;
        $this->client = $client === null ? $this->createClient() : $client;
        $this->databaseName = $databaseName === null ? $this->getFullDatabaseName() : $databaseName;
        $this->fullTableName = $this->databaseName . '-' . $this->resourceName;
        $this->marshaler = new Marshaler;
    }

    private function createClient()
    {
        $sdk = new Sdk([
            'region'   => getenv('AWS_SDK_REGION'),
            'version'  => getenv('AWS_SDK_VERSION'),
            'http' => [
                'verify' => getenv('AWS_SDK_HTTP_VERIFY') === 'false' ? false : getenv('AWS_SDK_HTTP_VERIFY'),
            ]
        ]);
        return $sdk->createDynamoDb();
    }

    private function getFullDatabaseName()
    {
        return getenv('AWS_DYNAMODB_NAMESPACE') . '-' . getenv('AWS_DYNAMODB_DATABASE');
    }

    public function get($resourceId = null)
    {
        if ($resourceId !== null) {
            return $this->getOne($resourceId);
        }
        return $this->getAll();
    }

    protected function getOne($resourceId)
    {
        $query = $this->createGetQuery($resourceId);
        $res = $this->client->getItem($query);
        return $this->unmarshalItem($res['Item']);
    }

    protected function createGetQuery($resourceId)
    {
        $query = [
            'TableName' => $this->fullTableName,
            'Key' => $this->marshalItem([$this->primaryKey => $resourceId]),
        ];
        return $query;
    }

    protected function getAll()
    {
        $query = $this->createScanQuery();
        $res = $this->client->scan($query);
        return $this->unmarshalBatch($res['Items']);
    }

    protected function createScanQuery()
    {
        $query = [
            'TableName' => $this->fullTableName,
        ];
        return $query;
    }

    protected function throwAwsPostError($exception)
    {
        switch ($exception->getAwsErrorCode()) {
            case 'ConditionalCheckFailedException':
                throw new RestException(
                    'Primary key collision',
                    ['exception' => $exception]
                );
        }
        throw new RestException($exception->getMessage(), ['exception' => $exception]);
    }

    public function post($newResource)
    {
        try {
            $query = $this->createPostQuery($newResource);
            $this->client->putItem($query);
        } catch (DynamoDbException $ex) {
            $this->throwAwsPostError($ex);
        } catch (\Exception $ex) {
            throw new RestException($ex->getMessage(), ['exception' => $ex]);
        }
        return $newResource;
    }

    protected function createPostQuery($newResource)
    {
        $query = [
            'TableName' => $this->fullTableName,
            'Item' => $this->marshalItem($newResource),
            'ConditionExpression' => 'attribute_not_exists(#pk)',
            "ExpressionAttributeNames" => ["#pk" => $this->primaryKey],
        ];
        return $query;
    }

    protected function throwAwsPutError($exception)
    {
        switch ($exception->getAwsErrorCode()) {
            case 'ConditionalCheckFailedException':
                throw new RestException(
                    'Resource does not exist',
                    ['exception' => $exception]
                );
        }
        throw new RestException($exception->getMessage(), ['exception' => $exception]);
    }

    public function put($resourceId, $newResource)
    {
        try {
            $newResource->{$this->primaryKey} = $resourceId;
            $query = $this->createPutQuery($newResource);
            $res = $this->client->putItem($query);
        } catch (DynamoDbException $ex) {
            $this->throwAwsPutError($ex);
        } catch (\Exception $ex) {
            throw new RestException($ex->getMessage(), ['result'=>empty($res)?null:$res]);
        }
        return $newResource;
    }

    protected function createPutQuery($newResource)
    {
        $query = [
            'TableName' => $this->fullTableName,
            'Item' => $this->marshalItem($newResource),
            'ConditionExpression' => 'attribute_exists(#pk)',
            "ExpressionAttributeNames" => ["#pk" => $this->primaryKey],
        ];
        return $query;
    }

    public function delete($resourceId)
    {
        try {
            $query = $this->createDeleteQuery($resourceId);
            $res = $this->client->deleteItem($query);
            return $resourceId;
        } catch (\Exception $ex) {
            throw new RestException($ex->getMessage(), ['result'=>empty($res)?null:$res]);
        }
    }

    protected function createDeleteQuery($resourceId)
    {
        $query = [
            'TableName' => $this->fullTableName,
            'Key' => $this->marshalItem([$this->primaryKey => $resourceId]),
        ];
        return $query;
    }

    protected function marshalItem($resource)
    {
        return $this->marshaler->marshalItem($resource);
    }

    protected function unmarshalItem($item)
    {
        if ($item === null) {
            return new \StdClass;
        }
        return $this->marshaler->unmarshalItem($item, true);
    }

    protected function unmarshalBatch($itemList)
    {
        if ($itemList === null) {
            return [];
        }
        $list = [];
        foreach ($itemList as $item) {
            $list[] = $this->unmarshalItem($item, true);

The call to Resource::unmarshalItem() has too many arguments starting with true.

        }
        return $list;
    }
}