Final Class Yiisoft\Rbac\Db\ItemsStorage

                public function __construct(
    private readonly ConnectionInterface $database,
    private readonly string $tableName = 'yii_rbac_item',
    private readonly string $childrenTableName = 'yii_rbac_item_child',
    string $namesSeparator = ',',
) {
    $this->assertNamesSeparator($namesSeparator);
    $this->namesSeparator = $namesSeparator;
}

            

                public function add(Item $item): void
{
    $this
        ->database
        ->createCommand()
        ->insert(
            $this->tableName,
            $item->getAttributes(),
        )
        ->execute();
}

            

                public function addChild(string $parentName, string $childName): void
{
    $this
        ->database
        ->createCommand()
        ->insert(
            $this->childrenTableName,
            ['parent' => $parentName, 'child' => $childName]
        )
        ->execute();
}

            

                public function clear(): void
{
    $itemsStorage = $this;
    $this->database->transaction(static function (ConnectionInterface $database) use ($itemsStorage): void {
        $database
            ->createCommand()
            ->delete($itemsStorage->childrenTableName)
            ->execute();
        $database
            ->createCommand()
            ->delete($itemsStorage->tableName)
            ->execute();
    });
}

            

                public function clearPermissions(): void
{
    $this->clearItemsByType(Item::TYPE_PERMISSION);
}

            

                public function clearRoles(): void
{
    $this->clearItemsByType(Item::TYPE_ROLE);
}

            

                public function exists(string $name): bool
{
    return (new Query($this->database))
        ->from($this->tableName)
        ->where(['name' => $name])
        ->exists();
}

            

                public function get(string $name): Permission|Role|null
{
    /** @psalm-var RawItem|null $row */
    $row = (new Query($this->database))
        ->from($this->tableName)
        ->where(['name' => $name])
        ->one();
    return $row === null ? null : $this->createItem($row);
}

            

                public function getAll(): array
{
    /** @psalm-var RawItem[] $rows */
    $rows = (new Query($this->database))
        ->from($this->tableName)
        ->all();
    return $this->getItemsIndexedByName($rows);
}

            

                public function getAllChildPermissions(string|array $names): array
{
    if (is_array($names) && empty($names)) {
        return [];
    }
    $rawItems = $this->getTreeTraversal()->getChildPermissionRows($names);
    /** @psalm-var array<string, Permission> */
    return $this->getItemsIndexedByName($rawItems);
}

            

                public function getAllChildRoles(string|array $names): array
{
    if (is_array($names) && empty($names)) {
        return [];
    }
    $rawItems = $this->getTreeTraversal()->getChildRoleRows($names);
    /** @psalm-var array<string, Role> */
    return $this->getItemsIndexedByName($rawItems);
}

            

                public function getAllChildren(string|array $names): array
{
    if (is_array($names) && empty($names)) {
        return [];
    }
    $rawItems = $this->getTreeTraversal()->getChildrenRows($names);
    return $this->getItemsIndexedByName($rawItems);
}

            

                public function getByNames(array $names): array
{
    if (empty($names)) {
        /** @infection-ignore-all  */
        return [];
    }
    /** @psalm-var RawItem[] $rawItems */
    $rawItems = (new Query($this->database))
        ->from($this->tableName)
        ->where(['name' => $names])
        ->all();
    return $this->getItemsIndexedByName($rawItems);
}

            

                public function getDirectChildren(string $name): array
{
    $quoter = $this->database->getQuoter();
    $quotedJoinColumn = $quoter->quoteTableName($this->tableName) . '.' . $quoter->quoteColumnName('name');
    /** @psalm-var RawItem[] $rawItems */
    $rawItems = (new Query($this->database))
        ->select($this->tableName . '.*')
        ->from($this->tableName)
        ->leftJoin(
            $this->childrenTableName,
            [$this->childrenTableName . '.child' => new Expression($quotedJoinColumn)],
        )
        ->where(['parent' => $name])
        ->all();
    return $this->getItemsIndexedByName($rawItems);
}

            

                public function getHierarchy(string $name): array
{
    $tree = [];
    $childrenNamesMap = [];
    foreach ($this->getTreeTraversal()->getHierarchy($name) as $data) {
        $childrenNamesMap[$data['name']] = $data['children'] !== '' && $data['children'] !== null
            ? explode($this->namesSeparator, $data['children'])
            : [];
        unset($data['children']);
        $tree[$data['name']] = ['item' => $this->createItem($data)];
    }
    foreach ($tree as $index => $_item) {
        $children = [];
        foreach ($childrenNamesMap[$index] as $childrenName) {
            if (!isset($tree[$childrenName])) {
                throw new SeparatorCollisionException();
            }
            $children[$childrenName] = $tree[$childrenName]['item'];
        }
        $tree[$index]['children'] = $children;
    }
    return $tree;
}

            

                public function getParents(string $name): array
{
    $rawItems = $this->getTreeTraversal()->getParentRows($name);
    return $this->getItemsIndexedByName($rawItems);
}

            

                public function getPermission(string $name): ?Permission
{
    return $this->getItemByTypeAndName(Item::TYPE_PERMISSION, $name);
}

            

                public function getPermissions(): array
{
    return $this->getItemsByType(Item::TYPE_PERMISSION);
}

            

                public function getPermissionsByNames(array $names): array
{
    if (empty($names)) {
        /** @infection-ignore-all  */
        return [];
    }
    /** @psalm-var RawPermission[] $rawItems */
    $rawItems = (new Query($this->database))
        ->from($this->tableName)
        ->where(['type' => Item::TYPE_PERMISSION, 'name' => $names])
        ->all();
    /** @psalm-var array<string, Permission> */
    return $this->getItemsIndexedByName($rawItems);
}

            

                public function getRole(string $name): ?Role
{
    return $this->getItemByTypeAndName(Item::TYPE_ROLE, $name);
}

            

                public function getRoles(): array
{
    return $this->getItemsByType(Item::TYPE_ROLE);
}

            

                public function getRolesByNames(array $names): array
{
    if (empty($names)) {
        /** @infection-ignore-all  */
        return [];
    }
    /** @psalm-var RawRole[] $rawItems */
    $rawItems = (new Query($this->database))
        ->from($this->tableName)
        ->where(['type' => Item::TYPE_ROLE, 'name' => $names])
        ->all();
    /** @psalm-var array<string, Role> */
    return $this->getItemsIndexedByName($rawItems);
}

            

                public function hasChild(string $parentName, string $childName): bool
{
    return $this->getTreeTraversal()->hasChild($parentName, $childName);
}

            

                public function hasChildren(string $name): bool
{
    return (new Query($this->database))
        ->from($this->childrenTableName)
        ->where(['parent' => $name])
        ->exists();
}

            

                public function hasDirectChild(string $parentName, string $childName): bool
{
    return (new Query($this->database))
        ->from($this->childrenTableName)
        ->where(['parent' => $parentName, 'child' => $childName])
        ->exists();
}

            

                public function remove(string $name): void
{
    $itemsStorage = $this;
    $this->database->transaction(static function (ConnectionInterface $database) use ($itemsStorage, $name): void {
        $itemsStorage->removeRelatedItemsChildren($database, $name);
        $database
            ->createCommand()
            ->delete($itemsStorage->tableName, ['name' => $name])
            ->execute();
    });
}

            

                public function removeChild(string $parentName, string $childName): void
{
    $this
        ->database
        ->createCommand()
        ->delete($this->childrenTableName, ['parent' => $parentName, 'child' => $childName])
        ->execute();
}

            

                public function removeChildren(string $parentName): void
{
    $this
        ->database
        ->createCommand()
        ->delete($this->childrenTableName, ['parent' => $parentName])
        ->execute();
}

            

                public function roleExists(string $name): bool
{
    return (new Query($this->database))
        ->from($this->tableName)
        ->where(['name' => $name, 'type' => Item::TYPE_ROLE])
        ->exists();
}

            

                public function update(string $name, Item $item): void
{
    $itemsStorage = $this;
    $this
        ->database
        ->transaction(static function (ConnectionInterface $database) use ($itemsStorage, $name, $item): void {
            /**
             * @var array[] $itemsChildren We assume that arrays are returned here, not objects.
             */
            $itemsChildren = (new Query($database))
                ->from($itemsStorage->childrenTableName)
                ->where(['parent' => $name])
                ->orWhere(['child' => $name])
                ->all();
            if ($itemsChildren !== []) {
                $itemsStorage->removeRelatedItemsChildren($database, $name);
            }
            $database
                ->createCommand()
                ->update($itemsStorage->tableName, $item->getAttributes(), ['name' => $name])
                ->execute();
            if ($itemsChildren !== []) {
                $itemsChildren = array_map(
                    static function (array $itemChild) use ($name, $item): array {
                        if ($itemChild['parent'] === $name) {
                            $itemChild['parent'] = $item->getName();
                        }
                        if ($itemChild['child'] === $name) {
                            $itemChild['child'] = $item->getName();
                        }
                        return [$itemChild['parent'], $itemChild['child']];
                    },
                    $itemsChildren,
                );
                $database
                    ->createCommand()
                    ->insertBatch($itemsStorage->childrenTableName, $itemsChildren, ['parent', 'child'])
                    ->execute();
            }
        });
}