Final Class Yiisoft\Rbac\Cycle\ItemsStorage

                public function __construct(
    private readonly DatabaseInterface $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(Permission|Role $item): void
{
    $this
        ->database
        ->insert($this->tableName)
        ->values($item->getAttributes())
        ->run();
}

            

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

            

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

            

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

            

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

            

                public function exists(string $name): bool
{
    /**
     * @psalm-var array<0, 1>|false $result
     * @infection-ignore-all
     * - ArrayItemRemoval, select.
     */
    $result = $this
        ->database
        ->select([new Fragment('1 AS item_exists')])
        ->from($this->tableName)
        ->where(['name' => $name])
        ->run()
        ->fetch();
    return $result !== false;
}

            

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

            

                public function getAll(): array
{
    /** @psalm-var RawItem[] $rows */
    $rows = $this
        ->database
        ->select()
        ->from($this->tableName)
        ->fetchAll();
    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)) {
        return [];
    }
    /** @psalm-var RawItem[] $rawItems */
    $rawItems = $this
        ->database
        ->select()
        ->from($this->tableName)
        ->where('name', 'IN', $names)
        ->fetchAll();
    return $this->getItemsIndexedByName($rawItems);
}

            

                public function getDirectChildren(string $name): array
{
    /** @psalm-var RawItem[] $rawItems */
    $rawItems = $this
        ->database
        ->select($this->tableName . '.*')
        ->from($this->tableName)
        ->leftJoin($this->childrenTableName)
        ->on($this->childrenTableName . '.child', $this->tableName . '.name')
        ->where(['parent' => $name])
        ->fetchAll();
    return $this->getItemsIndexedByName($rawItems);
}

            

                public function getHierarchy(string $name): array
{
    $tree = [];
    $childrenNamesMap = [];
    foreach ($this->getTreeTraversal()->getHierarchy($name) as $data) {
        $childrenNamesMap[$data['name']] = $data['children'] !== ''
            ? 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)) {
        return [];
    }
    /** @psalm-var RawPermission[] $rawItems */
    $rawItems = $this
        ->database
        ->select()
        ->from($this->tableName)
        ->where(['type' => Item::TYPE_PERMISSION])
        ->andWhere('name', 'IN', $names)
        ->fetchAll();
    /** @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)) {
        return [];
    }
    /** @psalm-var RawRole[] $rawItems */
    $rawItems = $this
        ->database
        ->select()
        ->from($this->tableName)
        ->where(['type' => Item::TYPE_ROLE])
        ->andWhere('name', 'IN', $names)
        ->fetchAll();
    /** @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
{
    /**
     * @psalm-var array<0, 1>|false $result
     * @infection-ignore-all
     * - ArrayItemRemoval, select.
     */
    $result = $this
        ->database
        ->select([new Fragment('1 AS item_child_exists')])
        ->from($this->childrenTableName)
        ->where(['parent' => $name])
        ->run()
        ->fetch();
    return $result !== false;
}

            

                public function hasDirectChild(string $parentName, string $childName): bool
{
    /**
     * @psalm-var array<0, 1>|false $result
     * @infection-ignore-all
     * - ArrayItemRemoval, select.
     */
    $result = $this
        ->database
        ->select([new Fragment('1 AS item_child_exists')])
        ->from($this->childrenTableName)
        ->where(['parent' => $parentName, 'child' => $childName])
        ->run()
        ->fetch();
    return $result !== false;
}

            

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

            

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

            

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

            

                public function roleExists(string $name): bool
{
    /**
     * @psalm-var array<0, 1>|false $result
     * @infection-ignore-all
     * - ArrayItemRemoval, select.
     */
    $result = $this
        ->database
        ->select([new Fragment('1 AS role_exists')])
        ->from($this->tableName)
        ->where(['name' => $name, 'type' => Item::TYPE_ROLE])
        ->run()
        ->fetch();
    return $result !== false;
}

            

                public function update(string $name, Permission|Role $item): void
{
    $itemsStorage = $this;
    $this
        ->database
        ->transaction(static function (Database $database) use ($itemsStorage, $name, $item): void {
            $itemsChildren = $database
                ->select()
                ->from($itemsStorage->childrenTableName)
                ->where(['parent' => $name])
                ->orWhere(['child' => $name])
                ->fetchAll();
            if ($itemsChildren !== []) {
                $itemsStorage->removeRelatedItemsChildren($database, $name);
            }
            $database
                ->update($itemsStorage->tableName, $item->getAttributes(), ['name' => $name])
                ->run();
            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
                    ->insert($itemsStorage->childrenTableName)
                    ->columns(['parent', 'child'])
                    ->values($itemsChildren)
                    ->run();
            }
        });
}