DynamoDbAdapter::delete() - Code Metrics - Inspection of "Code quality update." - guillermoandrae/php-dynamodb - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( d0befd...ebeab2 )

by Guillermo A.
created 2020-01-05 01:59 UTC
DynamoDbAdapter::delete() A

↳ Parent: DynamoDbAdapter
Complexity

Conditions	2
Paths	3
Size

Total Lines	8
Code Lines	6
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	6
CRAP Score	2
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
eloc	6
c	1
b	0
f	0
dl	0
loc	8
rs	10
ccs	6
cts	6
cp	1
cc	2
nc	3
nop	1
crap	2
<?php

namespace Guillermoandrae\Db\DynamoDb;

use Aws\DynamoDb\DynamoDbClient;
use Aws\DynamoDb\Exception\DynamoDbException;
use Aws\DynamoDb\Marshaler;
use Guillermoandrae\Common\Collection;
use Guillermoandrae\Common\CollectionInterface;
use Guillermoandrae\Db\AdapterInterface;
use Guillermoandrae\Db\DbException;
use InvalidArgumentException;

final class DynamoDbAdapter implements AdapterInterface
{
    /**
     * @var DynamoDbClient The DynamoDb client.
     */
    private $client;

    /**
     * @var Marshaler The JSON Marshaler.
     */
    private $marshaler;

    /**
     * @var string The table name.
     */
    private $tableName;

    /**
     * Registers the client and marshaler with this object. Sets up the
     * Repository factory and passes the Marshaler over to the request factory
     * as well.
     *
     * @param DynamoDbClient $client The DynamoDb client.
     * @param Marshaler $marshaler The JSON Marshaler.
     */
    public function __construct(DynamoDbClient $client, Marshaler $marshaler)
    {
        $this->setClient($client);
        $this->marshaler = $marshaler;
        RequestFactory::setMarshaler($marshaler);
    }

    /**
     * {@inheritDoc}
     */
    public function createTable(array $data): bool
    {
        try {
            $query = RequestFactory::factory('create-table', $this->tableName, $data)->get();
            $this->client->createTable($query);
            $this->client->waitUntil('TableExists', ['TableName' => $this->tableName]);
            return true;
        } catch (DynamoDbException $ex) {
            throw new DbException($ex->getMessage());
        } catch (InvalidArgumentException $ex) {
            throw new DbException('Bad key schema: ' . $ex->getMessage());
        }
    }

    /**
     * {@inheritDoc}
     */
    public function deleteTable(): bool
    {
        try {
            $query = RequestFactory::factory('delete-table', $this->tableName)->get();
            $this->client->deleteTable($query);
            $this->client->waitUntil('TableNotExists', ['TableName' => $this->tableName]);
            return true;
        } catch (DynamoDbException $ex) {
            throw new DbException($ex->getMessage());
        }
    }

    /**
     * {@inheritDoc}
     */
    public function describeTable(): array
    {
        try {
            $query = RequestFactory::factory('describe-table', $this->tableName)->get();
            $result = $this->client->describeTable($query);
            return $result['Table'];

        } catch (DynamoDbException $ex) {
            throw new DbException($ex->getMessage());
        }
    }

     /**
     * {@inheritDoc}
     */
    public function tableExists(): bool
    {
        $tables = $this->listTables();
        return in_array(
            strtolower($this->tableName),
            array_map('strtolower', $tables)
        );
    }

    /**
     * {@inheritDoc}
     */
    public function listTables(): array
    {
        $query = RequestFactory::factory('list-tables')->get();
        $results = $this->client->listTables($query);
        return $results['TableNames'];

    }

    /**
     * {@inheritDoc}
     */
    public function findAll(int $offset = 0, ?int $limit = null): CollectionInterface
    {
        try {
            $query = RequestFactory::factory('scan', $this->tableName)->get();
            $results = $this->client->scan($query);
            $rows = [];
            foreach ($results['Items'] as $item) {
                $rows[] = $this->marshaler->unmarshalItem($item);
            }
            $collection = Collection::make($rows);
            return $collection->limit($offset, $limit);
        } catch (DynamoDbException $ex) {
            throw new DbException($ex->getMessage());
        }
    }

    /**
     * {@inheritDoc}
     */
    public function findLatest(): array
    {
        try {
            $query = RequestFactory::factory('scan', $this->tableName)
                ->setLimit(1)
                ->/** @scrutinizer ignore-call */ setLimit(1)
                ->get();
            $results = $this->client->scan($query);
            return $this->marshaler->unmarshalItem($results['Items'][0]);

        } catch (DynamoDbException $ex) {
            throw new DbException($ex->getMessage());
        }
    }

    /**
     * {@inheritDoc}
     */
    public function findById($id): array
    {
        return $this->findByPrimaryKey($id);
    }

    /**
     * {@inheritDoc}
     */
    public function findByPrimaryKey($primaryKey): array
    {
        try {
            $query = RequestFactory::factory('get-item', $this->tableName, $primaryKey)->get();
            $results = $this->client->getItem($query);
            if (is_array($results['Item'])) {
                return $this->marshaler->unmarshalItem($results['Item']);
                return $this->marshaler->unmarshalItem(/** @scrutinizer ignore-type */ $results['Item']);
            }
interface ReturnsInt {
    public function returnsIntHinted(): int;
}

class MyClass implements ReturnsInt {
    public function returnsIntHinted(): int
    {
        if (foo()) {
            return 123;
        }
        // here: null is implicitly returned
    }
}
        } catch (DynamoDbException $ex) {
            throw new DbException($ex->getMessage());
        }
    }

    /**
     * {@inheritDoc}
     */
    public function insert(array $data): bool
    {
        try {
            $query = RequestFactory::factory('put-item', $this->tableName, $data)->get();
            $this->client->putItem($query);
            return true;
        } catch (DynamoDbException $ex) {
            throw new DbException($ex->getMessage());
        }
    }

    /**
     * {@inheritDoc}
     */
    public function delete($id): bool
    {
        try {
            $query = RequestFactory::factory('delete-item', $this->tableName, $id)->get();
            $this->client->deleteItem($query);
            return true;
        } catch (DynamoDbException $ex) {
            throw new DbException($ex->getMessage());
        }
    }

    /**
     * {@inheritDoc}
     */
    public function useTable(string $tableName): AdapterInterface
    {
        $this->tableName = $tableName;
        return $this;
    }

    /**
     * {@inheritDoc}
     */
    public function setClient($client): AdapterInterface
    {
        $this->client = $client;
        return $this;
    }

    /**
     * {@inheritDoc}
     */
    public function getClient(): DynamoDbClient
    {
        return $this->client;
    }
}

guillermoandrae / php-dynamodb

Push — master ( d0befd...ebeab2 )

DynamoDbAdapter::delete() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
