pax_global_header00006660000000000000000000000064132736162670014527gustar00rootroot0000000000000052 comment=befdef15928ed56e8c20826d99fbbc99a8ac4e8a msgphp-0.4.3/000077500000000000000000000000001327361626700130315ustar00rootroot00000000000000msgphp-0.4.3/.codecov.yml000066400000000000000000000004261327361626700152560ustar00rootroot00000000000000comment: off ignore: - "src/*/Tests/" - "src/*/Command/*Command.php" - "src/*/Event/*Event.php" - "src/*/Event/Domain/*Event.php" - "src/*/Infra/Doctrine/Type/*Type.php" - "src/*Bundle/Resources/" - "src/Domain/Infra/DependencyInjection/*Helper.php" msgphp-0.4.3/.editorconfig000066400000000000000000000001201327361626700154770ustar00rootroot00000000000000root = true [*] end_of_line = LF [*.php] indent_style = space indent_size = 4 msgphp-0.4.3/.env.dist000066400000000000000000000000161327361626700145610ustar00rootroot00000000000000GITHUB_TOKEN= msgphp-0.4.3/.github/000077500000000000000000000000001327361626700143715ustar00rootroot00000000000000msgphp-0.4.3/.github/ISSUE_TEMPLATE.md000066400000000000000000000001411327361626700170720ustar00rootroot00000000000000 msgphp-0.4.3/.github/PULL_REQUEST_TEMPLATE.md000066400000000000000000000001461327361626700201730ustar00rootroot00000000000000 msgphp-0.4.3/.gitignore000066400000000000000000000000751327361626700150230ustar00rootroot00000000000000/.env /var .php_cs.cache composer.lock composer.phar vendor/ msgphp-0.4.3/.lando.yml000066400000000000000000000005601327361626700147300ustar00rootroot00000000000000name: msgphp-ci recipe: custom services: appserver: type: php:7.1 tooling: php: service: appserver description: Run PHP commands cmd: - php composer: service: appserver description: Run Composer commands cmd: - composer bash: service: appserver description: Run bash commands cmd: - bash - -xc msgphp-0.4.3/.php_cs.dist000066400000000000000000000012661327361626700152550ustar00rootroot00000000000000 true, '@Symfony' => true, '@Symfony:risky' => true, '@PHP70Migration' => true, '@PHP70Migration:risky' => true, '@PHP71Migration' => true, '@PHP71Migration:risky' => true, '@PHPUnit60Migration:risky' => true, 'single_import_per_statement' => false, 'array_syntax' => ['syntax' => 'short'], ]; if (!is_dir($cacheDir)) { mkdir($cacheDir, 0770, true); } return Config::create() ->setUsingCache(true) ->setCacheFile($cacheDir . '/php_cs.cache') ->setRules($rules) ->setRiskyAllowed(true) ->setFinder(Finder::create()->in(__DIR__)) ; msgphp-0.4.3/.sami.dist000066400000000000000000000011551327361626700147270ustar00rootroot00000000000000files() ->name('*.php') ->ignoreDotFiles(true) ->ignoreVCS(true) ->exclude('vendor') ->exclude('Tests') ->in(__DIR__.'/src') ; return new Sami($iterator, [ 'title' => 'Message driven PHP - API', 'build_dir' => __DIR__.'/var/docs/build-api', 'cache_dir' => __DIR__.'/var/cache/api', 'remote_repository' => new GitHubRemoteRepository('msgphp/msgphp', __DIR__), 'default_opened_level' => 1, ]); msgphp-0.4.3/.travis.yml000066400000000000000000000031171327361626700151440ustar00rootroot00000000000000notifications: email: false language: php php: - 7.1 - 7.2 env: global: - COMPOSER_ARGS="--no-progress --prefer-dist --no-interaction --no-suggest" - PHPUNIT_ARGS="" matrix: include: - php: 7.1 env: - DEPS=high - CC=true - CS=true - SA=true - SMOKE_TEST=true - php: 7.2 env: - DEPS=low fast_finish: true before_script: - if [[ $CC != true ]] ; then phpenv config-rm xdebug.ini || true ; fi - if [[ $CS = true ]] ; then mkdir -p var/cache ; fi - travis_retry composer self-update before_install: - source .travis/tfold install: - travis_retry php .travis/packager.php HEAD^ $(find src/*/composer.json -type f -printf '%h\n') - if [[ ! $DEPS || $DEPS = high ]] ; then travis_retry bin/composer update $COMPOSER_ARGS ; fi - if [[ $DEPS = low ]] ; then travis_retry bin/composer update $COMPOSER_ARGS --prefer-stable --prefer-lowest ; fi - bin/phpunit install - if [[ $CS = true || $SA = true ]] ; then composer install $COMPOSER_ARGS ; fi script: - if [[ ! $CC ]] ; then bin/phpunit $PHPUNIT_ARGS ; fi - if [[ $CC = true ]] ; then bin/phpunit --coverage-clover=coverage.xml $PHPUNIT_ARGS ; fi - if [[ $CS = true ]] ; then bin/cs ; fi - if [[ $SA = true ]] ; then bin/sa ; fi - if [[ $SMOKE_TEST = true ]] ; then bin/smoke-test-bundles ; fi after_success: - if [[ $CC = true ]] ; then .travis/codecov ; fi cache: directories: - $HOME/.composer/cache/files/ - var/cache/ before_cache: - rm -rf $HOME/.composer/cache/files/msgphp branches: only: - master - /^\d\.\d$/ msgphp-0.4.3/.travis/000077500000000000000000000000001327361626700144175ustar00rootroot00000000000000msgphp-0.4.3/.travis/codecov000077500000000000000000000003321327361626700157650ustar00rootroot00000000000000#!/usr/bin/env bash for DIR in $(find src/ -maxdepth 1 -mindepth 1 -type d) ; do pushd $DIR &> /dev/null if [[ -f coverage.xml ]] ; then bash <(curl -s https://codecov.io/bash) ; fi popd &> /dev/null done msgphp-0.4.3/.travis/packager.php000077500000000000000000000061671327361626700167220ustar00rootroot00000000000000 $_SERVER['argc']) { echo "Usage: branch dir1 dir2 ... dirN\n"; exit(1); } chdir(dirname(__DIR__)); $dirs = $_SERVER['argv']; array_shift($dirs); $mergeBase = trim(shell_exec(sprintf('git merge-base %s HEAD', array_shift($dirs)))); $packages = array(); $flags = \PHP_VERSION_ID >= 50400 ? JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE : 0; foreach ($dirs as $k => $dir) { if (!system("git diff --name-only $mergeBase -- $dir", $exitStatus)) { if ($exitStatus) { exit($exitStatus); } unset($dirs[$k]); continue; } echo "$dir\n"; $json = ltrim(file_get_contents($dir.'/composer.json')); if (null === $package = json_decode($json)) { passthru("composer validate $dir/composer.json"); exit(1); } $package->repositories = array(array( 'type' => 'composer', 'url' => 'file://'.str_replace(DIRECTORY_SEPARATOR, '/', dirname(__DIR__)).'/', )); if (false === strpos($json, "\n \"repositories\": [\n")) { $json = rtrim(json_encode(array('repositories' => $package->repositories), $flags), "\n}").','.substr($json, 1); file_put_contents($dir.'/composer.json', $json); } passthru("cd $dir && tar -cf package.tar --exclude='package.tar' *"); if (!isset($package->extra->{'branch-alias'}->{'dev-master'})) { echo "Missing \"dev-master\" branch-alias in composer.json extra.\n"; exit(1); } $package->version = str_replace('-dev', '.x-dev', $package->extra->{'branch-alias'}->{'dev-master'}); $package->dist['type'] = 'tar'; $package->dist['url'] = 'file://'.str_replace(DIRECTORY_SEPARATOR, '/', dirname(__DIR__))."/$dir/package.tar"; $packages[$package->name][$package->version] = $package; $versions = file_get_contents('https://packagist.org/p/'.$package->name.'.json'); $versions = json_decode($versions)->packages->{$package->name}; if ($package->version === str_replace('-dev', '.x-dev', $versions->{'dev-master'}->extra->{'branch-alias'}->{'dev-master'})) { unset($versions->{'dev-master'}); } $packageName = $package->name; foreach ($versions as $v => $package) { $package->name = $packageName; $packages[$package->name] += array($v => $package); } } file_put_contents('packages.json', json_encode(compact('packages'), $flags)); //if ($dirs) { // $json = ltrim(file_get_contents('composer.json')); // if (null === $package = json_decode($json)) { // passthru("composer validate $dir/composer.json"); // exit(1); // } // // $package->repositories = array(array( // 'type' => 'composer', // 'url' => 'file://'.str_replace(DIRECTORY_SEPARATOR, '/', dirname(__DIR__)).'/', // )); // if (false === strpos($json, "\n \"repositories\": [\n")) { // $json = rtrim(json_encode(array('repositories' => $package->repositories), $flags), "\n}").','.substr($json, 1); // file_put_contents('composer.json', $json); // } //} msgphp-0.4.3/.travis/tfold000077500000000000000000000020461327361626700154570ustar00rootroot00000000000000#!/usr/bin/env bash # originally taken from https://github.com/symfony/symfony/blob/master/.travis.yml # Copyright (c) 2017 Fabien Potencier nanoseconds() { local cmd="date" local format="+%s%N" local os=$(uname) if hash gdate > /dev/null 2>&1; then cmd="gdate" elif [[ "$os" = Darwin ]]; then format="+%s000000000" fi $cmd -u $format } export -f nanoseconds # tfold is a helper to create folded reports tfold () { local title=$1 local fold=$(echo $title | sed -r 's/[^-_A-Za-z0-9]+/./g') shift local id=$(printf %08x $(( RANDOM * RANDOM ))) local start=$(nanoseconds) echo -e "travis_fold:start:$fold" echo -e "travis_time:start:$id" echo -e "\\e[1;34m$title\\e[0m" bash -xc "$*" 2>&1 local ok=$? local end=$(nanoseconds) echo -e "\\ntravis_time:end:$id:start=$start,finish=$end,duration=$(($end-$start))" (exit $ok) && echo -e "\\e[32mOK\\e[0m $title\\n\\ntravis_fold:end:$fold" || echo -e "\\e[41mKO\\e[0m $title\\n" (exit $ok) } export -f tfold msgphp-0.4.3/CONTRIBUTING.md000066400000000000000000000017431327361626700152670ustar00rootroot00000000000000# Contributing ## Testing ```bash # all packages bin/phpunit # single package bin/phpunit user-bundle ``` ## Code Style ```bash # all packages bin/cs # single package bin/cs user-bundle ``` ## Static Analysis ```bash # all packages bin/sa # single package bin/sa user-bundle ``` ## Helping others To checkout another open pull request from this repository use: ```bash bin/pr ``` It will add a new git remote `github-pr-XXX` pointing to the author's SSH URL and checkout their branch locally using the same name. ## Setup a test project To setup a test project use: ```bash bin/create-project ``` It will create a new Symfony skeleton application and ask you which bundles to install. The bundles can be automatically symlinked to your local clone after. ## Perform a smoke test To quickly see if CI is likely to pass use: ```bash bin/smoke-test bin/smoke-test-bundles ``` ## Using [Lando](https://docs.devwithlando.io) ```bash lando bash 'bin/ ' ``` msgphp-0.4.3/LICENSE000066400000000000000000000020601327361626700140340ustar00rootroot00000000000000MIT License Copyright (c) 2017 Roland Franssen Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. msgphp-0.4.3/README.md000066400000000000000000000050151327361626700143110ustar00rootroot00000000000000# Message driven PHP MsgPHP is a project that aims to provide (common) message based domain layers for your application. It has a low development time overhead and avoids being overly opinionated. [![Build Status](https://travis-ci.org/msgphp/msgphp.svg?branch=master)](https://travis-ci.org/msgphp/msgphp) [![codecov](https://codecov.io/gh/msgphp/msgphp/branch/master/graph/badge.svg)](https://codecov.io/gh/msgphp/msgphp) ## Documentation - Read the [main documentation](https://msgphp.github.io/docs/) - Browse the [API documentation](https://msgphp.github.io/api/) - Try the Symfony [demo application](https://github.com/msgphp/symfony-demo-app) - Get support on [Symfony's Slack `#msgphp` channel](https://symfony.com/slack-invite) or [raise an issue](https://github.com/msgphp/msgphp/issues/new) ## Packages Domain | Bundle --- | --- [`msgphp/domain`](https://github.com/msgphp/domain) | n/a [`msgphp/eav`](https://github.com/msgphp/eav) | [`msgphp/eav-bundle`](https://github.com/msgphp/eav-bundle) [`msgphp/user`](https://github.com/msgphp/user) | [`msgphp/user-bundle`](https://github.com/msgphp/user-bundle) ## Contributing See the [contributing](CONTRIBUTING.md) section. ## Blog posts - [Adding user management to your Symfony application](https://medium.com/@ro0NL/adding-user-management-to-your-symfony-application-ceeefe2a2e9) - [Domain-driven-design: Moving forward with API Platform and Elasticsearch](https://medium.com/@ro0NL/domain-driven-design-moving-forward-with-api-platform-and-elasticsearch-f1705614f9e2) - [Domain-driven-design: Writing domain layers. The fast way.](https://medium.com/@ro0NL/domain-driven-design-writing-domain-layers-the-fast-way-60ef87399374) - [Initializing objects with CLI and the power of Symfony Console](https://medium.com/@ro0NL/initializing-objects-with-cli-and-the-power-of-symfony-console-2a008d5611f) - [Commanding a decoupled User entity](https://medium.com/@ro0NL/commanding-a-decoupled-user-entity-aee8723c43e5) - [Decoupling the User entity with a new Symfony User Bundle](https://medium.com/@ro0NL/decoupling-the-user-entity-with-a-new-symfony-user-bundle-7d2d5d85bdf9) - [Continuous integration: Automate everything!](https://medium.com/@ro0NL/continuous-integration-automate-everything-6787758c4945) - [Continuous integration: Favoring stability and consistency by default!](https://medium.com/@ro0NL/continuous-integration-favoring-stability-and-consistency-by-default-147b33504675) - [Building a new Symfony User Bundle](https://medium.com/@ro0NL/building-a-new-symfony-user-bundle-b4fe5a9d9d80) msgphp-0.4.3/UPGRADE-0.2.md000066400000000000000000000014121327361626700147350ustar00rootroot00000000000000# UPGRADE FROM 0.1 to 0.2 ## Eav - Decoupled entity identifiers using abstract entities ## EavBundle - Removed `%msgphp.default_data_type%` DI parameter, use `default_id_type` bundle configuration instead - Removed `data_type_mapping` bundle configuration, use `id_type_mapping` instead ## User - Decoupled entity identifiers using abstract entities ## UserBundle - Removed `%msgphp.default_data_type%` DI parameter, use `default_id_type` bundle configuration instead - Removed `data_type_mapping` bundle configuration, use `id_type_mapping` instead - Configured param converter by name Before: ``` @ParamConverter("argument", options={"current": true}) ``` After: ``` @ParamConverter("argument", converter="msgphp.current_user") ``` msgphp-0.4.3/UPGRADE-0.3.md000066400000000000000000000006201327361626700147360ustar00rootroot00000000000000# UPGRADE FROM 0.2 to 0.3 ## Domain - Added `%msgphp.domain.class_mapping%` DI parameter to inject the full domain class mapping ## User - Enabled role `ROLE_DEFAULT` for users by default if no `UserRolesProviderInterface` is registered ## UserBundle - Added `make:user` when [`MakerBundle`](https://github.com/symfony/maker-bundle) is enabled. Consider (re-)generating your application code. msgphp-0.4.3/UPGRADE-0.4.md000066400000000000000000000016231327361626700147430ustar00rootroot00000000000000# UPGRADE FROM 0.3 to 0.4 ## Eav - Refactored `Entity\Fields\AttributeValueField` into `Entity\Features\EntityAttributeValue` - Added `Infra\Doctrine\Repository\EntityAttributeValueRepositoryTrait` - Added default domain messages (`Command\` and `Event\`) ## User - Renamed `UserAttributeValue::getAttributeValueId()` to `getId()` - Added `UserAttributeValue::changeValue()` - Deleted `UserAttributeValue::getAttributeValue()` - Renamed `ChangeUserAttributeValueCommand::$attributeValueId` to `$id` - Renamed `DeleteUserAttributeValueCommand::$attributeValueId` to `$id` ## UserBundle - Added support for Symfony Messenger and is favored over SimpleBus by default - Renamed default Twig variables Before: ``` {# Nullable #} {{ msgphp_user.user }} {{ msgphp_user.userId }} ``` After: ``` {# Not nullable #} {{ msgphp_user.current }} {{ msgphp_user.id }} ``` msgphp-0.4.3/bin/000077500000000000000000000000001327361626700136015ustar00rootroot00000000000000msgphp-0.4.3/bin/build-docs000077500000000000000000000017651327361626700155650ustar00rootroot00000000000000#!/usr/bin/env bash if [[ ! $# -eq 0 ]] ; then echo "Usage: $0" exit 1 fi REV=$(git rev-parse --abbrev-ref --short --verify HEAD) DIR="var/docs" mkdir -p "${DIR}" rm -rf var/cache/api bin/sami update .sami.dist bin/mkdocs build [[ $? -ne 0 ]] && exit 1 pushd "${DIR}" &> /dev/null echo -e "\e[34mSynchronizing source...\e[0m" if [[ ! -d src/.git ]] ; then echo "Cloning..." git clone --quiet git@github.com:msgphp/msgphp.github.io.git src [[ $? -ne 0 ]] && echo "Failed!" && exit 1 fi git -C src fetch --tags git -C src pull API_DIR="src/api" DOCS_DIR="src/docs" if [[ $REV != master ]] ; then DOCS_DIR="${DOCS_DIR}-${REV}" fi rm -rf "${DOCS_DIR}" "${API_DIR}" mv build "${DOCS_DIR}" mv build-api "${API_DIR}" echo -en "\e[34mPush docs for \"${REV}\"? [yN]\e[0m" read answer if [[ $answer =~ ^y|Y|yes|YES$ ]] ; then git -C src add --all git -C src commit -m "Update docs for \"${REV}\" to $(git rev-parse --short --verify HEAD)" git -C src push fi popd &> /dev/null msgphp-0.4.3/bin/clean000077500000000000000000000001351327361626700146100ustar00rootroot00000000000000#!/usr/bin/env bash rm -rf composer.lock var/ vendor/ bin/each rm -rf composer.lock vendor/ msgphp-0.4.3/bin/compile-docrefs000077500000000000000000000067741327361626700166200ustar00rootroot00000000000000#!/usr/bin/env php [], 'bundles' => []]; foreach (glob('src/*/composer.json') as $file) { $package = json_decode(file_get_contents($file)); $entry = ['path' => dirname($file), 'package' => $package]; if ('-bundle' === substr($package->name, -7)) { $result['bundles'][$package->name] = $entry; continue; } $result['domains'][$package->name] = $entry + [ 'entities' => array_map(function (string $file): array { return [ 'class' => $class = 'MsgPhp\\'.str_replace('/', '\\', substr($file, 4, -4)), 'abstract' => (new \ReflectionClass($class))->isAbstract(), ]; }, glob(dirname($file).'/Entity/*.php')), 'entity_fields' => array_map(function (string $file): string { return 'MsgPhp\\'.str_replace('/', '\\', substr($file, 4, -4)); }, glob(dirname($file).'/Entity/Fields/*Field.php')), 'entity_features' => array_map(function (string $file): string { return 'MsgPhp\\'.str_replace('/', '\\', substr($file, 4, -4)); }, array_filter(glob(dirname($file).'/Entity/Features/*.php'), function (string $file): bool { return 'Abstract' !== substr(basename($file), 0, 8); })), 'identifiers' => array_map(function (string $file): array { return [ 'class' => $class = 'MsgPhp\\'.str_replace('/', '\\', substr($file, 4, -4)), 'scalar' => class_exists($scalar = substr($class, 0, -9)) ? $scalar : null, 'uuid' => class_exists($uuid = 'MsgPhp\\'.basename(dirname($file)).'\\Infra\\Uuid\\'.basename($file, 'Interface.php')) ? $uuid : null, ]; }, glob(dirname($file).'/*IdInterface.php')), ]; } ksort($result['domains']); ksort($result['bundles']); $result['domains'] = [$k = 'msgphp/domain' => $result['domains'][$k]] + $result['domains']; return $result; }; $getTemplate = function (string $file) use ($msgphpGlobal): array { $oldBaseDir = getcwd(); chdir(dirname(__DIR__)); extract(['msgphp' => $msgphpGlobal()]); $template = include $file; chdir($oldBaseDir); return $template; }; $templates = $templateVars = []; foreach (glob('docs/.refs/*.php') as $reference) { $vars = $getTemplate($reference); $templates[$name = basename($reference, '.php')] = array_shift($vars); $templateVars[$name] = $vars; } $twig = new Environment(new ArrayLoader($templates)); $twig->addGlobal('msgphp', $msgphpGlobal()); $replacements = []; foreach (array_keys($templates) as $template) { $from = '~'.preg_quote($start = '', '~').'.*'.preg_quote($end = '', '~').'~s'; $to = $start."\n".$twig->render($template, $templateVars[$template]).$end; $replacements[$from] = $to; } foreach (glob('docs/{*,**/*}.md', \GLOB_BRACE) as $file) { file_put_contents($file, preg_replace(array_keys($replacements), array_values($replacements), file_get_contents($file))); } echo "\e[34mCompiled templates\e[0m\n"; echo ' > '.implode("\n > ", array_keys($templates))."\n"; msgphp-0.4.3/bin/composer000077500000000000000000000000561327361626700153570ustar00rootroot00000000000000#!/usr/bin/env bash bin/each composer "${@}" msgphp-0.4.3/bin/create-project000077500000000000000000000025671327361626700164500ustar00rootroot00000000000000#!/usr/bin/env bash if [[ $# -gt 1 ]] ; then echo "Usage: $0 []" exit 1 fi DIR="${1:-var/test-project/}" PACKAGES="orm " DEV_PACKAGES="debug maker server " for PACKAGE in $(find src/*Bundle/composer.json -type f) ; do PACKAGE_NAME=$(grep -E "^\s*\"name\"\s*:\s*\"msgphp\/([^\"]+)\"\s*,\s*$" "${PACKAGE}") if [[ ! -z $PACKAGE_NAME ]] ; then PACKAGE_NAME=$(echo "${PACKAGE_NAME}" | sed -e "s/^\s*\"name\":\s*\"msgphp\///" -e "s/\"\s*,\s*$//") echo -en "\e[34mInstall \"msgphp/${PACKAGE_NAME}\"? [yN]\e[0m " read answer if [[ $answer =~ ^y|Y|yes|YES$ ]] ; then PACKAGES="${PACKAGES}msgphp/${PACKAGE_NAME} " fi fi done composer create-project --prefer-dist --no-progress symfony/skeleton "${DIR}" [[ $? -ne 0 ]] && exit 1 pushd "${DIR}" &> /dev/null echo -e "\e[34mInstalling dependencies...\e[0m" composer config extra.symfony.allow-contrib true && \ composer require --prefer-dist --no-suggest ${PACKAGES} && \ composer require --prefer-dist --dev --no-suggest ${DEV_PACKAGES} [[ $? -ne 0 ]] && exit 1 popd &> /dev/null echo -en "\e[34mLink dependencies? [Yn]\e[0m" read answer if [[ ${answer:-y} =~ ^y|Y|yes|YES$ ]] ; then composer link -h &> /dev/null if [[ $? != 0 ]] ; then composer update --prefer-dist --quiet [[ $? -ne 0 ]] && exit 1 fi composer link "${DIR}" fi msgphp-0.4.3/bin/cs000077500000000000000000000006171327361626700141400ustar00rootroot00000000000000#!/usr/bin/env bash if [[ $# -eq 0 ]] ; then DIR="src/" elif [[ -d $1 ]] ; then DIR="$1" shift; else DIR="src/$(echo $1 | sed -r 's/(^|-)(\w)/\U\2/g')" shift; fi BIN="vendor/bin/php-cs-fixer" CMD="${BIN} fix --dry-run --verbose --diff ${@} ${DIR}" if [[ ! -f "${BIN}" ]] ; then composer update --prefer-dist --quiet [[ $? -ne 0 ]] && exit 1 fi bash -xc "${CMD}" 2>&1 msgphp-0.4.3/bin/each000077500000000000000000000007741327361626700144370ustar00rootroot00000000000000#!/usr/bin/env bash if [[ $# -lt 1 ]] ; then echo "Usage: $0 " exit 1 fi CMD="${@}" RETURN=0 for PACKAGE in $(find src/*/composer.json -type f) ; do DIR=$(dirname ${PACKAGE}) pushd "${DIR}" &> /dev/null LABEL="Running in \"${DIR}\"" if [[ $TRAVIS = true ]] ; then tfold "${LABEL}" "${CMD}" else echo -e "\e[34m${LABEL}\e[0m" bash -xc "${CMD}" 2>&1 fi LAST=$? ; [[ $LAST -ne 0 ]] && RETURN=${LAST} popd &> /dev/null done exit ${RETURN} msgphp-0.4.3/bin/mkdocs000077500000000000000000000002141327361626700150040ustar00rootroot00000000000000#!/usr/bin/env bash docker run --rm --group-add "$(id -g)" -u "$(id -u)" -it -p 8000:8000 -v ${PWD}:/docs squidfunk/mkdocs-material "${@}" msgphp-0.4.3/bin/phpunit000077500000000000000000000001011327361626700152060ustar00rootroot00000000000000#!/usr/bin/env bash bin/each ../../bin/phpunit-package . "${@}" msgphp-0.4.3/bin/phpunit-package000077500000000000000000000020261327361626700166070ustar00rootroot00000000000000#!/usr/bin/env bash if [[ $# -lt 1 ]] ; then echo "Usage: $0 []" exit 1 fi BASE_DIR="$(cd $(dirname $(dirname "$0")) && pwd)" if [[ -d $1 ]] ; then PACKAGE_DIR="$1" else PACKAGE_DIR="${BASE_DIR}/src/$(echo "$1" | sed -r 's/(^|-)(\w)/\U\2/g')" fi shift; BIN="vendor/bin/simple-phpunit" CMD="${BIN} ${@}" if [[ ! -f "${PACKAGE_DIR}/phpunit.xml.dist" ]] ; then echo "No valid package found in \"${PACKAGE_DIR}\"" exit 1 fi if [[ ! -f "${PACKAGE_DIR}/${BIN}" ]] ; then composer update --prefer-dist --quiet --working-dir="${PACKAGE_DIR}" [[ $? -ne 0 ]] && exit 1 fi if [[ ! $TRAVIS ]] ; then composer link -h &> /dev/null if [[ $? != 0 ]] ; then composer update --prefer-dist --quiet --working-dir="${BASE_DIR}" [[ $? -ne 0 ]] && exit 1 fi composer link --working-dir="${BASE_DIR}" "${PACKAGE_DIR}" [[ $? -ne 0 ]] && exit 1 fi pushd "${PACKAGE_DIR}" &> /dev/null echo -e "\e[34mTesting package\e[0m" bash -xc "${CMD}" 2>&1 popd &> /dev/null msgphp-0.4.3/bin/pr000077500000000000000000000034371327361626700141570ustar00rootroot00000000000000#!/usr/bin/env bash if [[ ! $# -eq 1 ]] ; then echo "Usage: $0 " exit 1 fi if [[ ! $1 =~ ^[1-9][0-9]*$ ]] ; then echo "Invalid pull request number \"$1\"" exit 1 fi source .env.dist if [[ -f .env ]] ; then source .env fi PR="$1" BRANCH="github-pr-${PR}" URL="https://api.github.com/repos/msgphp/msgphp/pulls/${PR}" if [[ ! -z $GITHUB_TOKEN ]] ; then URL="$URL?access_token=${GITHUB_TOKEN}" fi if [[ ! $(git branch --list ${BRANCH}) ]] ; then BODY=$(curl -sS -w ">>>%{http_code}" "${URL}") if [[ ! $BODY =~ \>\>\>200\s*$ ]] ; then echo "Error fetching pull request #${PR}..." echo "${BODY}" exit 1 fi BODY=$(echo "${BODY}" | sed -e "s/>>>200$//" -e "s/\\\/\\\\\\\/g") UPSTREAM_SSH_URL=$(cat < /dev/null git remote add "${BRANCH}" "${UPSTREAM_SSH_URL}" --fetch --track "${UPSTREAM_BRANCH}" if [[ $? -eq 1 ]] ; then git remote remove "${BRANCH}" echo "Pull request closed. Aborted." exit 1 fi git branch --set-upstream-to "${BRANCH}/${UPSTREAM_BRANCH}" fi if [[ ! -z $(git status --porcelain) ]] ; then echo "Current working directory must be clean to continue..." exit 1 fi git checkout "${BRANCH}" git pull msgphp-0.4.3/bin/sa000077500000000000000000000006301327361626700141310ustar00rootroot00000000000000#!/usr/bin/env bash if [[ $# -eq 0 ]] ; then DIR="src/" elif [[ -d $1 ]] ; then DIR="$1" shift; else DIR="src/$(echo $1 | sed -r 's/(^|-)(\w)/\U\2/g')" shift; fi BIN="vendor/bin/phpstan" CMD="${BIN} analyse --configuration phpstan.neon --level max ${@} ${DIR}" if [[ ! -f $BIN ]] ; then composer update --prefer-dist --quiet [[ $? -ne 0 ]] && exit 1 fi bash -xc "${CMD}" 2>&1 msgphp-0.4.3/bin/sami000077500000000000000000000002751327361626700144640ustar00rootroot00000000000000#!/usr/bin/env bash if [[ ! -f var/cache/sami.phar ]] ; then mkdir -p var/cache curl -so var/cache/sami.phar http://get.sensiolabs.org/sami.phar fi php var/cache/sami.phar "${@}" msgphp-0.4.3/bin/smoke-test000077500000000000000000000005701327361626700156240ustar00rootroot00000000000000#!/usr/bin/env bash if [[ ! $# -eq 0 ]] ; then echo "Usage: $0" exit 1 fi echo -e "\e[34mUpdating dependencies...\e[0m" bin/composer update --prefer-dist --quiet && composer update --prefer-dist --quiet [[ $? -ne 0 ]] && exit 1 echo -e "\e[34mCode Style / Static Analysis\e[0m" bin/cs && bin/sa [[ $? -ne 0 ]] && exit 1 echo -e "\e[34mUnit Tests\e[0m" bin/phpunit msgphp-0.4.3/bin/smoke-test-bundles000077500000000000000000000045361327361626700172640ustar00rootroot00000000000000#!/usr/bin/env bash if [[ ! $# -eq 0 ]] ; then echo "Usage: $0" exit 1 fi BASE_DIR="$(cd $(dirname $(dirname "$0")) && pwd)" rm -rf var/smoke-test/bundles/*Bundle/ if [[ ! -d var/smoke-test/bundles/base ]] ; then mkdir -p var/smoke-test/bundles/base fi pushd var/smoke-test/bundles/base &> /dev/null if [[ -d vendor ]] ; then composer update --prefer-dist --quiet else composer create-project --prefer-dist --quiet symfony/skeleton . && \ composer config extra.symfony.allow-contrib true && \ composer require --prefer-dist --quiet orm fi [[ $? -ne 0 ]] && exit 1 popd &> /dev/null PACKAGER="" if [[ -f "${BASE_DIR}/packages.json" ]] ; then PACKAGER="${PACKAGER}composer config repositories.main composer file://${BASE_DIR}/ && " elif [[ ! $TRAVIS ]] ; then for PACKAGE in $(find src/*/composer.json -type f) ; do PACKAGE_NAME=$(grep -E "^\s*\"name\"\s*:\s*\"msgphp\/([^\"]+)\"\s*,\s*$" "${PACKAGE}") if [[ ! -z $PACKAGE_NAME ]] ; then PACKAGE_NAME=$(echo "${PACKAGE_NAME}" | sed -e "s/^\s*\"name\":\s*\"msgphp\///" -e "s/\"\s*,\s*$//") PACKAGER="${PACKAGER}composer config repositories.${PACKAGE_NAME} path ${BASE_DIR}/$(dirname "${PACKAGE}")/ && " fi done fi RETURN=0 for PACKAGE in $(find src/*Bundle/composer.json -type f) ; do PACKAGE_NAME=$(grep -E "^\s*\"name\"\s*:\s*\"msgphp\/([^\"]+)\"\s*,\s*$" "${PACKAGE}") if [[ ! -z $PACKAGE_NAME ]] ; then PACKAGE_NAME=$(echo "${PACKAGE_NAME}" | sed -e "s/^\s*\"name\":\s*\"msgphp\///" -e "s/\"\s*,\s*$//") DIR="var/smoke-test/bundles/$(basename $(dirname "${PACKAGE}"))" CMD="${PACKAGER}composer require --no-progress --no-suggest --no-interaction " for DEP in $(composer show --name-only --working-dir="$(dirname "${PACKAGE}")" | grep msgphp/) ; do CMD="${CMD}${DEP}:@dev " done CMD="${CMD}msgphp/${PACKAGE_NAME}:@dev && \ bin/console doctrine:schema:validate --skip-sync" cp -R var/smoke-test/bundles/base "${DIR}" pushd "${DIR}" &> /dev/null if [[ $TRAVIS = true ]] ; then tfold "Testing ${PACKAGE_NAME}" "${CMD}" else echo -e "\e[34mTesting ${PACKAGE_NAME}\e[0m" bash -xc "${CMD}" 2>&1 fi LAST=$? ; [[ $LAST -ne 0 ]] && RETURN=${LAST} popd &> /dev/null fi done exit ${RETURN} msgphp-0.4.3/bin/subtree-split000077500000000000000000000030461327361626700163340ustar00rootroot00000000000000#!/usr/bin/env bash if [[ $# -gt 1 ]] ; then echo "Usage: $0 []" exit 1 fi DIR="${1:-var/subtree-split/}" mkdir -p "${DIR}" pushd "${DIR}" &> /dev/null echo -e "\e[34mSetup tooling...\e[0m" if [[ ! -d bin/.git ]] ; then echo "Cloning..." git clone --quiet git@github.com:msgphp/git-subtree-sync.git bin [[ $? -ne 0 ]] && echo "Failed!" && exit 1 fi git -C bin pull echo -e "\e[34mSynchronizing source...\e[0m" if [[ ! -d main/.git ]] ; then rm -rf .gitsubtree main subtrees mkdir main subtrees echo "Cloning..." git clone --quiet git@github.com:msgphp/msgphp.git main [[ $? -ne 0 ]] && echo "Failed!" && exit 1 fi git -C main fetch --tags git -C main pull if [[ ! -f .gitsubtree ]] ; then PACKAGES="" for PACKAGE in $(find main/src/*/composer.json -type f) ; do PACKAGE_NAME=$(grep -E "^\s*\"name\"\s*:\s*\"msgphp\/([^\"]+)\"\s*,\s*$" "${PACKAGE}") if [[ ! -z $PACKAGE_NAME ]] ; then PACKAGE_NAME=$(echo "${PACKAGE_NAME}" | sed -e "s/^\s*\"name\":\s*\"msgphp\///" -e "s/\"\s*,\s*$//") PACKAGE_PATH="src/$(basename $(dirname "${PACKAGE}"))/" echo -e "\e[34mFound package \"msgphp/${PACKAGE_NAME}\" at \"${PACKAGE_PATH}\"\e[0m" PACKAGES="$PACKAGES [\"${PACKAGE_NAME}\"]=\"${PACKAGE_PATH}\""$'\n' fi done cat >.gitsubtree < /dev/null msgphp-0.4.3/composer.json000066400000000000000000000014111327361626700155500ustar00rootroot00000000000000{ "description": "Composer configuration for bulk CI testing of packages", "require-dev": { "wikimedia/composer-merge-plugin": "^1.4", "friendsofphp/php-cs-fixer": "^2.10", "phpstan/phpstan": "^0.9", "phpstan/phpstan-phpunit": "^0.9", "phpunit/phpunit": "^7.0", "ro0nl/link": "^1.0", "twig/twig": "^2.4" }, "autoload-dev": { "psr-4": { "MsgPhp\\": "src/" } }, "extra": { "merge-plugin": { "include": [ "src/*/composer.json" ] } }, "replace": { "msgphp/domain": "*", "msgphp/eav": "*", "msgphp/eav-bundle": "*", "msgphp/user": "*", "msgphp/user-bundle": "*" } } msgphp-0.4.3/docs/000077500000000000000000000000001327361626700137615ustar00rootroot00000000000000msgphp-0.4.3/docs/.refs/000077500000000000000000000000001327361626700147765ustar00rootroot00000000000000msgphp-0.4.3/docs/.refs/available-bundles.php000066400000000000000000000002441327361626700210610ustar00rootroot00000000000000name][$class::NAME] = $class; } ksort($types[$domain['package']->name]); } $template = <<<'MD' {% for package, info in types %} ## `{{ package }}` Type name | Type class --- | --- {% for name, class in info %} `{{ name }}` | `{{ class }}` {% endfor %} {% endfor %} MD; return [$template, 'types' => $types]; msgphp-0.4.3/docs/.refs/entities.php000066400000000000000000000010771327361626700173400ustar00rootroot00000000000000 {% endblock %} msgphp-0.4.3/docs/.theme/style.css000066400000000000000000000006341327361626700170160ustar00rootroot00000000000000.md-nav__link[data-md-state="blur"] { word-break: break-all; } .md-nav__link[data-md-state="blur"]:before { content: "✔"; } .md-nav__link.md-nav__link--active:before { content: "↘"; } .md-typeset h3 > code:first-child:before { content: "▍"; } .md-typeset h3 > code { font-weight: bold; } .md-typeset p code { color: #e83e8c; word-break: break-all; } .md-typeset p a > code { text-decoration: underline; } msgphp-0.4.3/docs/code-conventions.md000066400000000000000000000034001327361626700175550ustar00rootroot00000000000000# Code Conventions A brief description of code conventions this project follows. ## General Principles - Follows [SOLID] principles - Reduce [lines of code] where possible - Reduce coupling ([Law of Demeter]) - Favor latest stable PHP7 features - Checks must pass (code style, static analysis & unit tests) ## Code Style (CS) - Follows [PSR-2] with [Symfony Style] - `use` statements are declared in alpha-order - `use` statements for `MsgPhp\` namespace are grouped by deepest common namespace ```php - `msgphp/eav-bundle`: Basic entity-attribute-value management (the `EAV` domain) - `msgphp/user-bundle`: Basic user management (the `User` domain) ## Installation ```bash composer require msgphp/-bundle ``` !!! info When [Symfony Flex] is used to mange your Symfony application the minimal bundle configuration is created for you automatically based on [MsgPHP recipes] ## Configuration By default a bundle provides the following minimal configuration: ```yaml # config/packages/msgphp_.yaml msgphp_: # e.g. "msgphp_user" class_mapping: [] id_type_mapping: [] default_id_type: integer commands: [] ``` Depending on your personal preference you can also write the configuration in any other supported format. !!! info See the [demo configuration] for a more advanced example ### `class_mapping` Configures the bundle with a class mapping to tell which classes of yours should be used for a known class of ours. ```yaml msgphp_: class_mapping: MsgPhp\SomeClass: App\SomeClass ``` The class mapping applies when working with an [object factory](../ddd/factory/object.md). Depending on the bundle a specific class mapping entry might enable one of the bundle its features which is otherwise disabled by default. ### `id_type_mapping` Configures the bundle [domain identifier](../ddd/identifiers.md) types. Each key must be a sub class of `MsgPhp\Domain\DomainIdInterface` whereas each value must be a known type name. It ensures a default class mapping entry is added which maps the identifier to a [concrete implementation](../ddd/identifiers.md#implementations). ```yaml msgphp_: id_type_mapping: MsgPhp\SomeDomain\SomeIdInterface: some_type_name ``` !!! note See the [reference](../reference/identifiers.md) page for all available identifiers provided per domain By convention any [Doctrine DBAL type] can be used for a type name. Additionally the following UUID types are detected as well: - `uuid` - `uuid_binary` - `uuid_binary_ordered_time` ### `default_id_type` Configures a default type name to use for all known domain identifiers provided by the bundle. ```yaml msgphp_: default_id_type: uuid ``` ### `commands` By default a command handler provided by the bundle might be enabled or disabled depending on an [entity feature](../ddd/entities.md#common-entity-features) is being used yes or no. However, in case of a [event-sourcing command handler](../message-driven/cqrs.md#event-sourcing-command-handler) the corresponding [domain event](../event-sourcing/events.md) might be supported regardless. Depending on your own [event handler](../event-sourcing/event-handlers.md) implementation. To keep leveraging default command handlers they can be explicitly enabled or disabled by command. ```yaml msgphp_: commands: MsgPhp\SomeCommand: true MsgPhp\SomeOtherCommand: false ``` ## Basic Configuration Example Given a bundle provides the following domain identifiers: - `MsgPhp\FooIdInterface` - `MsgPhp\BarIdInterface` - `MsgPhp\BazIdInterface` ```yaml msgphp_: default_id_type: uuid id_type_mapping: MsgPhp\FooIdInterface: integer # implied: # MsgPhp\BarIdInterface: uuid # MsgPhp\BazIdInterface: uuid class_mapping: MsgPhp\BarIdInterface: App\MyBarUuid # implied: # MsgPhp\FooIdInterface: MsgPhp\Domain\DomainId # MsgPhp\BazIdInterface: MsgPhp\Domain\Infra\Uuid\DomainId ``` [Symfony Framework]: https://symfony.com/ [dependency injection]: https://symfony.com/doc/current/components/dependency_injection.html [Symfony Flex]: https://symfony.com/doc/current/setup/flex.html [MsgPHP recipes]: https://github.com/symfony/recipes-contrib/tree/master/msgphp [autowiring]: https://symfony.com/doc/current/service_container/autowiring.html [demo configuration]: https://github.com/msgphp/symfony-demo-app/blob/master/config/packages/msgphp.php [Doctrine DBAL type]: http://docs.doctrine-project.org/projects/doctrine-dbal/en/latest/reference/types.html msgphp-0.4.3/docs/cookbook/configuring-doctrine-orm.md000066400000000000000000000112131327361626700230210ustar00rootroot00000000000000# Configuring Doctrine ORM After a [bundle](bundle-installation.md) is installed we can configure [Doctrine ORM](../infrastructure/doctrine-orm.md). ## Installation ```bash composer install doctrine/orm doctrine/doctrine-bundle # using Symfony Flex composer install orm ``` ## Configuration See the Doctrine Bundle [recipe configuration] for the minimal configuration to put in `config/packages/doctrine.yaml`. Although the examples use annotation based mappings, you are not required to do so. [Read more][doctrine-bundle-mapping-config]. !!! info The configuration is automatically added when using Symfony Flex ## Mapping Entities A MsgPHP bundle provides base entity models in the form of [mapped superclasses]. An actual entity object must be defined by your application: ```php : # ... class_mapping: MsgPhp\SomeDomain\Entity\SomeEntity: App\Entity\SomeEntity ``` !!! note See the [reference](../reference/entities.md) page for all available entities provided per domain !!! info When using a default entity _field-_ or _feature-trait_ a default ORM mapping is configured automatically !!! info When using Symfony Flex the required entities of a MsgPHP bundle are automatically created, including ORM mapping and configuration ## Mapping Identifiers When an entity object is identified using a [domain identifier](../ddd/identifiers.md) we must configure it accordingly: ```php : # ... class_mapping: MsgPhp\SomeDomain\SomeIdInterface: App\SomeId id_type_mapping: MsgPhp\SomeDomain\SomeIdInterface: bigint ``` ### Without Nullability ```php id = $id; } public function getId(): SomeIdInterface { return $this->id; } } ``` Or coupled with a known identifier class: ```php id = new SomeId(); } // ... } ``` ### Without Automatic Hydration To hydrate the primitive identifier value instead of a value object, the type can be configured regularly. It requires to couple with a known identifier class. ```php id = $id->isEmpty() ? null : (int) $id->toString(); } public function getId(): SomeIdInterface { return SomeId::fromValue($this->id); } } ``` !!! info [Read more](../infrastructure/doctrine-orm.md#domain-identifier-hydration) about Doctrine identifier hydration ## Database Setup Configure the database URL: ```bash # .env # sqlite DATABASE_URL=sqlite:///%kernel.project_dir%/var/db.sqlite # mysql / mariadb DATABASE_URL="mysql://user:pass@host:3306/db_name?charset=utf8mb4&serverVersion=5.7" ``` Create the database schema: ```bash bin/console doctrine:database:create bin/console doctrine:schema:update --force ``` [recipe configuration]: https://github.com/symfony/recipes/blob/master/doctrine/doctrine-bundle/1.6/config/packages/doctrine.yaml [doctrine-bundle-mapping-config]: https://symfony.com/doc/master/bundles/DoctrineBundle/configuration.html#mapping-configuration [mapped superclasses]: https://www.doctrine-project.org/projects/doctrine-orm/en/latest/reference/inheritance-mapping.html#mapped-superclasses msgphp-0.4.3/docs/ddd/000077500000000000000000000000001327361626700145145ustar00rootroot00000000000000msgphp-0.4.3/docs/ddd/collections.md000066400000000000000000000061241327361626700173570ustar00rootroot00000000000000# Collections A domain collection is a [traversable] and bound to `MsgPhp\Domain\DomainCollectionInterface`. Its purpose is to utilize a primitive iterable value. It may hold any type of element values. ## API ### Extends - [`\Countable`][countable] - [`\IteratorAggregate`][iterator-aggregate] --- ### `static fromValue(?iterable $value): DomainCollectionInterface` Returns a factorized collection from any primitive iterable. Using `null` implies an empty collection. --- ### `isEmpty(): bool` Tells if a collection is considered empty, i.e. contains zero elements. --- ### `contains($element): bool` Tells if a collection contains the given element. Comparison is done strictly. --- ### `containsKey($key): bool` Tells if a collection contains an element at the given key/index. --- ### `first()` Returns the first element or `false` if the collection is empty. --- ### `last()` Returns the last element or `false` if the collection is empty. --- ### `get($key)` Returns the element at the given key/index or `null` if the collection is empty. --- ### `filter(callable $filter): DomainCollectionInterface` Returns a **new** collection containing only elements for which `$filter` returns `true`. Keys are preserved. --- ### `slice(int $offset, int $limit = 0): DomainCollectionInterface` Returns a **new** collection containing a slice of elements. By default the slice has no limit, implied by integer `0`. Keys are preserved. --- ### `map(callable $mapper): array` Returns a map with each collection element as returned by `$mapper`. ## Implementations ### `MsgPhp\Domain\DomainCollection` A first class citizen domain collection. It leverages `iterable` as underlying data type. Lazy support is built-in for type `\Traversable`. Meaning the minimal no. of elements are traversed, i.e. until the first element in case of `isEmpty()`. Note type `\Generator` can only start traversing once. - `__construct(iterable $elements)` - `$elements`: The elements this collection contains #### Basic example ```php 'value']); // --- USAGE --- $collection->isEmpty(); // false count($collection); // int(7) $collection->contains(2); // true $collection->contains('2'); // false $collection->containsKey(0); // true $collection->containsKey('0'); // true $collection->first(); // "a" $collection->last(); // int(3) $collection->get('0'); // "a" $collection->get(3); // int(1) $collection->get('key'); // "value" $onlyInts = $collection->filter(function ($value): bool { return is_int($value); }); $firstTwoInts = $onlyInts->slice(0, 2); $firstTwoIntsPlussed = $firstTwoInts->map(function (int $value): int { return ++$value; }); // [2, 4] ``` ### `MsgPhp\Domain\Infra\Doctrine\DomainCollection` A Doctrine tailored domain collection. - [Read more](../infrastructure/doctrine-collections.md#domain-collection) [traversable]: https://secure.php.net/traversable [countable]: https://secure.php.net/countable [iterator-aggregate]: https://secure.php.net/iteratoraggregate msgphp-0.4.3/docs/ddd/entities.md000066400000000000000000000044271327361626700166710ustar00rootroot00000000000000# Entities Entity objects are provided per domain layer and usually follow a [POPO] design. To simplify its definition common fields and features are provided in the form of PHP [traits]. Fields can be compared to a read-operation, whereas features represent a read/write-operation. They are defined in a dedicated namespace for discovery, respectively `Msgphp\Domain\Entity\Fields\` and `MsgPhp\Domain\Entity\Features\`. Additionally more specific fields and features can be provided per domain layer. !!! note See the [reference](../reference/entities.md) page for all available entities provided per domain ## Entity Fields ### `CreatedAtField` A datetime value representing an entity was initially created at. Requires `$createdAt` to be set initially. - `getCreatedAt(): \DateTimeInterface` ### `EnabledField` A boolean value representing an entity its availability state. Sets `$enabled` to `false` by default. - `isEnabled(): bool` ### `LastUpdatedAtField` A datetime value representing an entity was last updated at. Requires `$lastUpdatedAt` to be set initially. - `getLastUpdatedAt(): \DateTimeInterface` ## Entity Features ### `CanBeConfirmed` Provides ability to confirm an entity. Requires `$confirmationToken` to be set initially (usually a random token). - `getConfirmationToken(): ?string` - `getConfirmedAt(): ?\DateTimeInterface` - `isConfirmed(): bool` - `confirm(): void` - Resets `$confirmationToken` - Sets `$confirmatedAt` to the current datetime ### `CanBeEnabled` Provides ability to toggle an entity its availability state. - Inherits from `EnabledField` - `enable(): void` - Sets `$enabled` to `true` - `disable(): void` - Sets `$enabled` to `false` ## Basic Example ```php createdAt = new \DateTimeImmutable(); } } // --- USAGE --- $entity = new MyEntity(); $createdAt = $entity->getCreatedAt(); if (!$entity->isEnabled()) { $entity->enable(); } ``` [POPO]: https://stackoverflow.com/questions/41188002/what-does-the-term-plain-old-php-object-popo-exactly-mean [traits]: https://secure.php.net/traits msgphp-0.4.3/docs/ddd/factory/000077500000000000000000000000001327361626700161635ustar00rootroot00000000000000msgphp-0.4.3/docs/ddd/factory/entity-aware.md000066400000000000000000000046411327361626700211230ustar00rootroot00000000000000# Entity Aware Factory An entity aware factory is an [object factory](object.md) and additionally bound to `MsgPhp\Domain\Factory\EntityAwareFactoryInterface`. Its purpose is to factorize entity related objects. ## API ### Extends - [`DomainObjectFactoryInterface`](object.md) --- ### `reference(string $class, $id): object` Returns a factorized reference object for a known existing entity object. The object must be of type `$class`. Any type of [identity](../identities.md) value can be passed as `$id`. --- ### `identify(string $class, $value): DomainIdInterface` Returns a factorized [domain identifier](../identifiers.md) for the given entity class from a known primitive value. --- ### `nextIdentifier(string $class): DomainIdInterface` Returns the next [domain identifier](../identifiers.md) for the given entity class. Depending on the implementation its value might be considered empty if it's not capable to calculate one upfront. ## Implementations ### `MsgPhp\Domain\Factory\EntityAwareFactory` A generic entity factory. It decorates any object factory and uses the [domain identity mapping](../identity-mapping.md) as well as a known entity to identifier class mapping. - `__construct(DomainObjectFactoryInterface $factory, DomainIdentityMappingInterface $identityMapping, array $identifierMapping = [])` - `$factory`: The decorated object factory - `$identityMapping`: The identity mapping - `$identifierMapping`: The identifier class mapping (`['EntityType' => 'IdType']`) #### Basic example ```php id = $id; } } $factory = new EntityAwareFactory( new DomainObjectFactory(), new DomainIdentityMapping([ MyEntity::class => 'id', ]), [ MyEntity::class => DomainId::class, ] ); // --- USAGE --- /** @var MyEntity $ref */ $ref = $factory->reference(MyEntity::class, new DomainId('1')); /** @var DomainId $id */ $id = $factory->identify(MyEntity::class, 1); /** @var DomainId $id */ $id = $factory->nextIdentifier(MyEntity::class); ``` ### `MsgPhp\Domain\Infra\Doctrine\EntityAwareFactory` A Doctrine tailored entity aware factory. - [Read more](../../infrastructure/doctrine-orm.md#entity-aware-factory) msgphp-0.4.3/docs/ddd/factory/object.md000066400000000000000000000067731327361626700177700ustar00rootroot00000000000000# Object Factory A domain object factory is bound to `MsgPhp\Domain\Factory\DomainObjectFactoryInterface`. Its purpose is to initialize any domain object based on a given class name and context. ## API ### `create(string $class, array $context = []): object` Returns a factorized domain object by class name. Optionally a context can be provided for the factory to act upon. ## Implementations ### `MsgPhp\Domain\Factory\DomainObjectFactory` A generic object factory. It initializes the given class by reading its constructor arguments. Argument values are resolved from the provided context. By convention a camel cased argument name (e.g. `$myArgument`) matches a corresponding underscored context key (i.e. `'my_argument'`), note however, an exact match (i.e. `'myArgument'`) has higher precedence. In case the context key is numeric its value will be provided to a corresponding argument at index N. Any sub class of `MsgPhp\Domain\DomainIdInterface` or `MsgPhp\Domain\DomainCollectionInterface` will be initialized using `$class::fromValue()` by default, otherwise initialization happens regularly (i.e. `new $class(...$arguments)`). Nested objects (e.g. `MyObject $myArgument`) can be provided as nested context (thus nested array). - `setNestedFactory(?DomainObjectFactoryInterface $factory): void` - `$factory`: The optional factory to use for nested objects. If not set the current factory will be used instead. #### Basic example ```php create(Subject::class, [ 'argument' => 'value', 'some' => [1, 2, 3], 'other_subject' => [ 'argument' => 'other_value', 'some' => ['a' => 1], ], ]); ``` ### `MsgPhp\Domain\Factory\ChainObjectFactory` A chain object factory. It holds many object factories and returns a domain object from the first supporting factory. - `__construct(iterable $factories)` - `$factories`: Available object factories #### Basic example ```php 'TargetType']`) #### Basic example ```php Subject::class] ); // --- USAGE --- /** @var Subject $object */ $object = $factory->create(KnownInterface::class); ``` msgphp-0.4.3/docs/ddd/factory/static.md000066400000000000000000000026321327361626700177770ustar00rootroot00000000000000# Static Factory A static factory is a utility class. Its purpose is to ease factorizing some known implementation in a static way. ## Implementations ### `MsgPhp\Domain\Factory\DomainIdFactory` Factorizes an [domain identifier](../identifiers.md). - `static create($value): DomainIdInterface` - `$value`: Any (primitive) identifier value #### Basic example ```php isEmpty(); // true $id->isEmpty(); // false $emptyId->equals($emptyId); // true $emptyId->equals(new DomainId()); // false $id->equals(new DomainId('1')); // true $id->equals(new OtherDomainId('1')); // false due type varying $emptyId->toString(); // "" (string) $id; // "1" $emptyStringId = new DomainId(''); $emptyStringId->isEmpty() ? null : $emptyStringId->toString(); // "" $emptyId->isEmpty() ? null : $emptyId->toString(); // null ``` ### `MsgPhp\Domain\Infra\Uuid\DomainId` A UUID tailored domain identifier. - [Read more](../infrastructure/uuid.md#domain-identifier) [string-able]: https://secure.php.net/manual/en/language.oop5.magic.php#object.tostring [serializable]: https://secure.php.net/serializable [json-serializable]: https://secure.php.net/jsonserializable msgphp-0.4.3/docs/ddd/identities.md000066400000000000000000000076411327361626700172070ustar00rootroot00000000000000# Identities `MsgPhp\Domain\DomainIdentityHelper` is a utility domain service. Its purpose is to ease working with domain identities and the [identity mapping](identity-mapping.md). A domain identity is a composite value (`array`) of one or more individual identifier values, indexed by an identifier field name. Its usage is to uniquely identify a domain object, thus qualifying it an entity object. Identifier values can be of any type; a [domain identifier](identifiers.md), another (foreign) entity object, or any primitive value. A single identifier value might represent an actual identity in case it's composed by a single identifier field. ## API ### `isIdentifier($value): bool` Tells if `$value` is a known identifier value. This is either a [domain identifier](identifiers.md) object or an entity object. --- ### `isEmptyIdentifier($value): bool` Tells if `$value` is a known empty identifier value. It returns `true` if the specified value is either `null`, an empty [domain identifier](identifiers.md) or an entity object without its identity set. --- ### `normalizeIdentifier($value)` Returns the primitive identifier value of `$value`. Empty identifier values (see `isEmptyIdentifier()`) are normalized as `null`, a [domain identifier](identifiers.md) as string value and an entity object as normalized identity value. A value of any other type is returned as is. --- ### `getIdentifiers(object $object): array` Returns the actual identifier values of `$object`. --- ### `getIdentifierFieldNames(string $class): array` Returns the identifier field names for `$class`. Any instance should have an identity composed of these field values. See also `DomainIdentityMappingInterface::getIdentifierFieldNames()`. --- ### `isIdentity(string $class, $value): bool` Tells if `$value` is a valid identity for type `$class`. An identity value is considered valid if an entity object uses a single identifier value as identity and `$value` is a non empty identifier (see `isEmptyIdentifier()`). In case of one or more identifier values, given in the form of an array, its keys must exactly match the available identifier field names and its values must contain no empty identifiers. --- ### `toIdentity(string $class, $value): array` Returns a composite identity value for `$class` from `$value`. --- ### `getIdentity(object $object): array` Returns the actual, non empty, identifier values of `$object`. Each identifier value is keyed by its corresponding identifier field name. See also `DomainIdentityMappingInterface::getIdentity()`. ## Basic Example ```php 'id', MyCompositeEntity::class => ['name', 'year'], ])); // --- USAGE --- $entity = new MyEntity(); $entity->id = new DomainId('1'); $compositeEntity = new MyCompositeEntity(); $compositeEntity->name = ...; $compositeEntity->year = ...; $helper->isIdentity('1'); // false $helper->isIdentity(new DomainId('1')); // true $helper->isIdentity($entity); // true $helper->normalizeIdentifier(new DomainId()); // null $helper->normalizeIdentifier(new DomainId('1')); // "1" $helper->normalizeIdentifier('1'); // "1" $helper->normalizeIdentifier($entity); // "1" $helper->normalizeIdentifier($compositeEntity); // ['name' => ..., 'year' => ....] $helper->getIdentifiers($entity); // [] $helper->getIdentifiers($compositeEntity); // [, ] $helper->isIdentity(MyEntity::class, 1); // true $helper->isIdentity(MyCompositeEntity::class, 1); // false $helper->isIdentity(MyCompositeEntity::class, ['name' => ...]); // false $helper->isIdentity(MyCompositeEntity::class, ['name' => ..., 'year' => ...]); // true $helper->toIdentity(MyEntity::class, 1); // ['id' => 1] ``` msgphp-0.4.3/docs/ddd/identity-mapping.md000066400000000000000000000036621327361626700203270ustar00rootroot00000000000000# Identity Mapping An identity mapping is a domain service and is bound to `MsgPhp\Domain\DomainIdentityMappingInterface`. It tells about the identifier metadata for a known domain object. ## API ### `getIdentifierFieldNames(string $class): array` Returns the identifier field names for `$class`. Any instance should have an identity composed of these field values. --- ### `getIdentity(object $object): array` Returns the actual, non empty, identifier values of `$object`. Each identifier value is keyed by its corresponding identifier field name. ## Implementations ### `MsgPhp\Domain\Infra\InMemory\DomainIdentityMapping` Identity mapping based on a known in-memory mapping. - `__construct(array $mapping, ObjectFieldAccessor $accessor = null)` - `$mapping`: The identity mapping to use - `$accessor`: Custom object field accessor. See also [`ObjectFieldAccessor`][api-objectfieldaccessor]. #### Basic example ```php 'id', MyCompositeEntity::class => ['name', 'year'], ]); // --- USAGE --- $entity = new MyEntity(); $entity->id = ...; $compositeEntity = new MyCompositeEntity(); $compositeEntity->name = ...; $compositeEntity->year = ...; $mapping->getIdentifierFieldNames(MyEntity::class); // ['id'] $mapping->getIdentifierFieldNames(MyCompositeEntity::class); // ['name', 'year'] $mapping->getIdentity($entity); // ['id' => ...] $mapping->getIdentity($compositeEntity); // ['name' => ..., 'year' => ...] ``` ### `MsgPhp\Domain\Infra\Doctrine\DomainIdentityMapping` A Doctrine tailored identity mapping. - [Read more](../infrastructure/doctrine-orm.md#domain-identity-mapping) [api-objectfieldaccessor]: https://msgphp.github.io/api/MsgPhp/Domain/Infra/InMemory/ObjectFieldAccessor.html msgphp-0.4.3/docs/ddd/repositories.md000066400000000000000000000067501327361626700175750ustar00rootroot00000000000000# Repositories A domain repository is not interface bound by default. Instead you can leverage a utility trait, tied to specific infrastructure (e.g. Doctrine), to rapidly create one. This page describes the API provided by default [implementations](#implementations). ## API ### `doFindAll(int $offset = 0, int $limit = 0): DomainCollectionInterface` Finds all entities available. An unlimited collection is implied by `$limit` set to zero. --- ### `doFindAllByFields(array $fields, int $offset = 0, int $limit = 0): DomainCollectionInterface` Finds all entities matching all specified fields. Supported field values should be `null`, `scalar`, `array` (one of a known literal list) and `object` (foreign entity or an [identifier](identifiers.md)). An unlimited collection is implied by `$limit` set to zero. --- ### `doFind($id): object` Finds a single entity by its identity. Supported identity values should be `scalar`, `array` (composite [identity](identities.md)) and `object` (foreign entity or an [identifier](identifiers.md)). --- ### `doFindByFields(array $fields): object` Finds the first entity matching all specified fields. See `doFindAllByFields()` for supported field values. --- ### `doExists($id): bool` Verifies if an entity exists by its identity. See `doFind()` for supported identity values. --- ### `doExistsByFields(array $fields): bool` Verifies if an entity matching all specified fields exists. See `doFindAllByFields()` for supported field values. --- ### `doSave(object $entity): void` Persists an entity into the identity map. The entity will be available on any subsequent query. --- ### `doDelete(object $entity): void` Removes an entity from the identity map. The entity will be unavailable on any subsequent query. ## Implementations ### `MsgPhp\Domain\Infra\InMemory\DomainEntityRepositoryTrait` Repository trait based on in-memory persistence. - `__construct(string $class, DomainIdentityHelper $identityHelper, GlobalObjectMemory $memory = null, ObjectFieldAccessor $accessor = null)` - `$class`: The entity class this repository is tied to - `$identityHelper`: The domain identity helper. [Read more](identities.md). - `$memory`: Custom memory layer. By default the same global pool is used. See also [`GlobalObjectMemory`][api-globalobjectmemory]. - `$accessor`: Custom object field accessor. See also [`ObjectFieldAccessor`][api-objectfieldaccessor]. #### Basic example ```php 'id', ])); $repository = new MyEntityRepository(MyEntity::class, $helper); // --- USAGE --- if ($repository->exists(1)) { $entity = $repository->find(1); } else { $entity = new MyEntity(); $entity->id = 1; $repository->save($entity); } ``` ### `MsgPhp\Domain\Infra\Doctrine\DomainEntityRepositoryTrait` A Doctrine tailored repository trait. - [Read more](../infrastructure/doctrine-orm.md#domain-repository) [api-globalobjectmemory]: https://msgphp.github.io/api/MsgPhp/Domain/Infra/InMemory/GlobalObjectMemory.html [api-objectfieldaccessor]: https://msgphp.github.io/api/MsgPhp/Domain/Infra/InMemory/ObjectFieldAccessor.html msgphp-0.4.3/docs/event-sourcing/000077500000000000000000000000001327361626700167315ustar00rootroot00000000000000msgphp-0.4.3/docs/event-sourcing/event-handlers.md000066400000000000000000000035031327361626700221730ustar00rootroot00000000000000# Event Handlers A domain event handler is bound to `MsgPhp\Domain\Event\DomainEventHandlerInterface`. Its purpose is to implement the handling of [domain events](events.md) within a certain context. Usually an entity implements it in order to mutate its own state (i.e. self-handling). It enforces the entity state to be valid by design as it encapsulates all write operations. In practice domain events can be recorded on trigger. It allows to re-play them at any point in time afterwards. Consider this a design choice to be made upfront, e.g. in case your entity design requires its history to be accessible. ## API ### `handleEvent(DomainEventInterface $event): bool` Handles the given domain event for a known subject. A boolean return value tells if the domain event is actually handled yes or no. ## Implementations ### `MsgPhp\Domain\Event\DomainEventHandlerTrait` A utility trait implementing the event handler API. By convention it maps events to `handleEvent()` methods. It's designed to support default [events](events.md#implementations) out-of-the-box. #### Basic example ```php newValue = $value; } } class MyEntity implements DomainEventHandlerInterface { use DomainEventHandlerTrait; public $value; private function handleMyEvent(MyEvent $event): bool { if ($this->value === $event->newValue) { return false; } $this->value = $event->newValue; return true; } } // --- USAGE --- $entity = new MyEntity(); if ($entity->handleEvent(new MyEvent('new value'))) { // do something } ``` msgphp-0.4.3/docs/event-sourcing/events.md000066400000000000000000000013431327361626700205600ustar00rootroot00000000000000# Events A domain event is bound to `MsgPhp\Domain\Event\DomainEventInterface`. Its purpose is to identify concrete domain events which represent something that happens. When handled it might lead to an application state change. ## Implementations ### `MsgPhp\Domain\Event\ConfirmEvent` Triggers a confirmation. Handled by default with `MsgPhp\Domain\Entity\Features\CanBeConfirmed::handleConfirmEvent()`. ### `MsgPhp\Domain\Event\DisableEvent` Triggers disabling availability. Handled by default with `MsgPhp\Domain\Entity\Features\CanBeEnabled::handleDisableEvent()`. ### `MsgPhp\Domain\Event\EnableEvent` Triggers enabling availability. Handled by default with `MsgPhp\Domain\Entity\Features\CanBeEnabled::handleEnableEvent()`. msgphp-0.4.3/docs/index.md000066400000000000000000000014051327361626700154120ustar00rootroot00000000000000# MsgPHP Documentation > [MsgPHP](https://msgphp.github.io/) is a project that aims to provide (common) message based domain layers for your application. It has a low development time overhead and avoids being overly opinionated. --- # News - **`2018-03-24`** Added initial _projection_ chapter - **`2018-03-18`** Added initial _cookbook_ and _reference_ chapters - **`2018-02-18`** Added initial _infrastructure_ chapter - **`2018-02-12`** Added [domain identities](ddd/identities.md) chapter - **`2018-01-27`** Added initial _message driven_ chapter - **`2018-01-26`** Added initial _event sourcing_ chapter - **`2018-01-25`** Added initial project [code conventions](code-conventions.md) - **`2018-01-18`** Initial documentation setup. Work in progress as of today. msgphp-0.4.3/docs/infrastructure/000077500000000000000000000000001327361626700170415ustar00rootroot00000000000000msgphp-0.4.3/docs/infrastructure/api-platform.md000066400000000000000000000027231327361626700217620ustar00rootroot00000000000000# API Platform An overview of available infrastructural code when using [API Platform]. - Requires [api-platform/core] ## Domain Projection Data Provider When working with [projections](../projection/models.md) an [API Data Provider] is provided by `MsgPhp\Domain\Infra\ApiPlatform\DomainProjectionDataProvider`. It uses any [projection repository](../projection/repositories.md) in an effort to provide API resources. ### Minimal configuration ```yaml api_platform: resource_class_directories: - '%kernel.project_dir%/src/Api/Projection' ``` !!! note See also [API Platform Configuration] documentation ### Basic example ```php id = $document['id'] ?? null; return $projection; } } ``` [API Platform]: https://api-platform.com/ [api-platform/core]: https://packagist.org/packages/api-platform/core [API Data Provider]: https://api-platform.com/docs/core/data-providers [API Platform Configuration]: https://api-platform.com/docs/core/configuration msgphp-0.4.3/docs/infrastructure/doctrine-collections.md000066400000000000000000000016211327361626700235060ustar00rootroot00000000000000# Doctrine Collections An overview of available infrastructural code when using Doctrine's [Collections][collections-project]. - Requires [doctrine/collections] ## Domain Collection A Doctrine tailored [domain collection](../ddd/collections.md) is provided by `MsgPhp\Domain\Infra\Doctrine\DomainCollection`. It decorates any `Doctrine\Common\Collections\Collection` type. - `__construct(Collection $collection)` - `$collection`: The decorated collection ### Basic example ```php exists($id = ['name' => ..., 'year' => ...])) { $entity = $repository->find($id); } else { $entity = new MyEntity(); $entity->name = ...; $entity->year = ...; $repository->save($entity); } ``` ## Entity Aware Factory A Doctrine tailored [entity aware factory](../ddd/factory/entity-aware.md) is provided by `MsgPhp\Domain\Infra\Doctrine\EntityAwareFactory`. It decorates any entity aware factory and uses Doctrine's [`EntityManagerInterface`][api-em]. Its purpose is to create lazy-loading references when using `reference()` (see [`EntityManagerInterface::getReference()`][api-em-getreference]) and handle an entity its discriminator map when working with [inheritance][orm-inheritance]. - `__construct(EntityAwareFactoryInterface $factory, EntityManagerInterface $em, array $classMapping = [])` - `$factory`: The decorated factory - `$em`: The entity manager to use - `$classMapping`: Global class mapping. Usually used to map abstracts to concretes. ### Basic example ```php reference(MyEntity::class, 1); // no database hit /** @var MyOtherEntity $otherRef */ $otherRef = $factory->reference(MyEntity::class, [ 'id' => 1, 'discriminator' => MyEntity::TYPE_OTHER ]); /** @var MyOtherEntity $otherEntity */ $otherEntity = $factory->create(MyEntity::class, [ 'discriminator' => MyEntity::TYPE_OTHER, ]); ``` ## Domain Identifier Hydration When working with [domain identifiers](../ddd/identifiers.md) and its corresponding [type](doctrine-dbal.md#domain-identifier-type) a problem might occur when hydrating scalar values, e.g. using [`Query::getScalarResult()`][api-query-getscalarresult]; it would return instances of `MsgPhp\Domain\DomainIdInterface` that can only be casted to string as its (true) scalar value (due to `__toString()`). In case the underlying data type is e.g. `integer` we'll lose it. To overcome, two hydration modes are available in order to hydrate the primitive identifier value instead. ### Basic example ```php getConfiguration(); $config->addCustomHydrationMode(ScalarHydrator::NAME, ScalarHydrator::class); $config->addCustomHydrationMode(SingleScalarHydrator::NAME, SingleScalarHydrator::class); // --- USAGE --- $query = $em->createQuery('SELECT entity.id FORM MyEntity entity'); $query->getScalarResult()[0]['id']; // "1" $query->getResult(ScalarHydrator::NAME)[0]['id']; // int(1) $query->getSingleScalarResult(); // "1" $query->getSingleResult(SingleScalarHydrator::NAME); // int(1) ``` [orm-project]: http://www.doctrine-project.org/projects/orm.html [orm-inheritance]: http://docs.doctrine-project.org/projects/doctrine-orm/en/latest/reference/inheritance-mapping.html [doctrine/orm]: https://packagist.org/packages/doctrine/orm [api-em]: http://www.doctrine-project.org/api/orm/2.5/class-Doctrine.ORM.EntityManagerInterface.html [api-em-getreference]: http://www.doctrine-project.org/api/orm/2.5/class-Doctrine.ORM.EntityManagerInterface.html#_getReference [api-query-getscalarresult]: http://www.doctrine-project.org/api/orm/2.5/class-Doctrine.ORM.AbstractQuery.html#_getScalarResult msgphp-0.4.3/docs/infrastructure/elasticsearch.md000066400000000000000000000072621327361626700222040ustar00rootroot00000000000000# Elasticsearch An overview of available infrastructural code when using Elasticsearch's [PHP Api][elasticsearch-project]. - Requires [elasticsearch/elasticsearch] ## Domain Projection Type Registry An Elasticsearch tailored [domain projection type registry](../projection/type-registry.md) is provided by `MsgPhp\Domain\Infra\Elasticsearch\DomainProjectionTypeRegistry`. It works directly with any [`Client`][api-client] and a known configuration of type information. - `__construct(Client $client, string $index, array $mappings, array $settings = [], LoggerInterface $logger = null)` - `$client`: The client to work with - `$index`: The index to use - `$mappings` / `$settings`: Index management information. [Read more][index management]. - `$logger`: An optional [PSR logger] ### Basic example ```php someField = $document['some_field'] ?? null; $projection->otherField = $document['other_field'] ?? null; return $projection; } } /** @var Client $client */ $client = ...; $typeRegistry = new DomainProjectionTypeRegistry($client, 'some_index', [ MyProjection::class => [ 'some_field' => 'some_type', // defaults to ['type' => 'some_type'] 'other_field' => [ // defaults to ['type' => 'text', ...] // ... ], ], ]); ``` ### Advanced mapping example ```php [ 'some_field' => 'some_type', 'other_field' => [ // ... ], ]; } } /** @var Client $client */ $client = ...; $typeRegistry = new DomainProjectionTypeRegistry($client, 'some_index', [ MyProjection::class, ]); ``` ## Domain Projection Repository An Elasticsearch tailored [domain projection repository](../projection/repositories.md) is provided by `MsgPhp\Domain\Infra\Elasticsearch\DomainProjectionRepository`. It works directly with any [`Client`][api-client]. - `__construct(Client $client, string $index)` - `$client`: The Client to work with - `$index`: The index to use ### Basic example ```php dispatch(new SomeMessage()); ``` [SimpleBus]: http://docs.simplebus.io [simple-bus/message-bus]: https://packagist.org/packages/simple-bus/message-bus msgphp-0.4.3/docs/infrastructure/symfony-console.md000066400000000000000000000135361327361626700225370ustar00rootroot00000000000000# Symfony Console An overview of available infrastructural code when using [Symfony Console][console-project]. - Requires [symfony/console] ## Commands Various standard [console commands] are available and can be used depending on implemented domain infrastructure. They are defined in the `MsgPhp\Domain\Infra\Console\Command\` namespace. ### `InitializeDomainProjectionTypesCommand` Initializes the [projection type registry](../projection/type-registry.md). ```bash bin/console projection:initialize-types [--force] ``` ### `SynchronizeDomainProjectionsCommand` Synchronizes domain objects and their [projections](../projection/models.md) using the [projection synchronization](../projection/synchronization.md) utility service. ```bash bin/console projection:synchronize ``` ## Context Factory A context factory is bound to `MsgPhp\Domain\Infra\Console\Context\ContextFactoryInterface`. Its purpose is to leverage a CLI command in an effort to interactively built an arbitrary array value (the context). ### API #### `configure(InputDefinition $definition): void` Configures a command input definition. See also [`InputDefinition`][api-inputdefinition]. Should be called before using `getContext()`. --- #### `getContext(InputInterface $input, StyleInterface $io, array $values = []): array` Resolves the actual context from the console IO. See also [`InputInterface`][api-inputinterface] and [`StyleInterface`][api-styleinterface]. Any element value provided by `$values` takes precedence and should be used as-is. ### Implementations #### `MsgPhp\Domain\Infra\Console\Context\ClassContextFactory` Factorizes a context based on any class method signature. It configures the CLI signature by mapping required class method arguments to command arguments, whereas optional ones are mapped to command options. ```bash bin/console command --optional-argument [--] required-argument ``` In both cases a value is optional, if the actual class method argument is required and no value is given it will be asked interactively. If interaction is not possible an exception will be thrown instead. - `__construct(string $class, string $method, array $classMapping = [], int $flags = 0, ClassContextElementFactoryInterface $elementFactory = null)` - `$class / $method`: The class method to resolve - `$classMapping`: Global class mapping. Usually used to map abstracts to concretes. - `$flags`: A bit mask value to toggle various flags - `ClassContextBuilder::ALWAYS_OPTIONAL`: Always map class method arguments to command options - `ClassContextBuilder::NO_DEFAULTS`: Leave out default values when calling `getContext()` - `ClassContextBuilder::REUSE_DEFINITION`: Reuse the original input definition for matching class method arguments - `$elementFactory`: A custom element factory to use. See also [Customizing context elements](#customizing-context-elements). ##### Customizing context elements Per-element configuration can be provided by implementing a `MsgPhp\Domain\Infra\Console\Context\ClassContextElementFactoryInterface`. - `getElement(string $class, string $method, string $argument): ContextElement` - Get a custom [`ContextElement`][api-contextelement] to apply to a specific class/method/argument pair A default implementation is provided by `MsgPhp\Domain\Infra\Console\Context\ClassContextElementFactory` which simply transforms argument names to human readable values so that `$argumentName` becomes `Argument Name`. ##### Basic example ```php contextFactory = new ClassContextFactory(MyObject::class, '__construct'); parent::__construct(); } protected function configure(): void { $this->setName('my-command'); $this->contextFactory->configure($this->getDefinition()); } protected function execute(InputInterface $input,OutputInterface $output): int { $io = new SymfonyStyle($input, $output); $context = $this->contextFactory->getContext($input, $io); $object = new MyObject(...array_values($context)); // do something return 0; } } // --- USAGE --- // $ bin/console my-command [--option=OPTION] [--] [] ``` #### `MsgPhp\Domain\Infra\Console\Context\DoctrineEntityContextFactory` A [Doctrine](doctrine-orm.md) entity aware context factory. It decorates any context factory. Its purpose is to provide a discriminator value into the resulting context when working with [inheritance][orm-inheritance]. - `__construct(ContextFactoryInterface $factory, EntityManagerInterface $em, string $class)` - `$factory`: The decorated context factory - `$em`: The entity manager to use - `$class`: The entity class to use [console-project]: https://symfony.com/doc/current/components/console.html [symfony/console]: https://packagist.org/packages/symfony/console [console commands]: https://symfony.com/doc/current/console.html [api-inputdefinition]: https://api.symfony.com/master/Symfony/Component/Console/Input/InputDefinition.html [api-inputinterface]: https://api.symfony.com/master/Symfony/Component/Console/Input/InputInterface.html [api-styleinterface]: https://api.symfony.com/master/Symfony/Component/Console/Style/StyleInterface.html [api-contextelement]: https://msgphp.github.io/api/MsgPhp/Domain/Infra/Console/Context/ContextElement.html [orm-inheritance]: http://docs.doctrine-project.org/projects/doctrine-orm/en/latest/reference/inheritance-mapping.html msgphp-0.4.3/docs/infrastructure/symfony-messenger.md000066400000000000000000000016571327361626700230660ustar00rootroot00000000000000# Symfony Messenger An overview of available infrastructural code when using [Symfony Messenger][messenger-project]. - Requires [symfony/messenger] ## Domain Message Bus A Symfony Messenger tailored [domain message bus](../message-driven/message-bus.md) is provided by `MsgPhp\Domain\Infra\Messenger\DomainMessageBus`. It decorates any `Symfony\Component\Messenger\MessageBusInterface` type. - `__construct(MessageBusInterface $bus)` - `$bus`: The decorated bus ### Basic example ```php dispatch(new SomeMessage()); ``` [messenger-project]: https://symfony.com/doc/current/components/messenger.html [symfony/messenger]: https://packagist.org/packages/symfony/messenger msgphp-0.4.3/docs/infrastructure/uuid.md000066400000000000000000000022631327361626700203340ustar00rootroot00000000000000# Universally Unique Identifier An overview of available infrastructural code when working with [UUIDs][uuid]. - Requires [ramsey/uuid] ## Domain Identifier A UUID tailored [domain identifier](../ddd/identifiers.md) is provided by `MsgPhp\Domain\Infra\Uuid\DomainId`. It leverages type `Ramsey\Uuid\UuidInterface` as underlying data type. - `__construct(UuidInterface $uuid = null)` - `$uuid`: The underlying UUID. In case of `null` a UUID version 4 value is generated upfront. Meaning the identifier will never be considered empty. !!! note See the [reference](../reference/identifiers.md) page for all available UUID identifiers provided per domain ### Basic example ```php handle($command, function (MyEntity $entity): void { // do something when $command is handled }); } protected function getDomainEvent(MyCommand $command): DomainEventInterface { return new MyDomainEvent(); } protected function getDomainEventHandler(MyCommand $command): DomainEventHandlerInterface { return new MyEntity(); } } class MyDomainEvent implements DomainEventInterface { } class MyEntity implements DomainEventHandlerInterface { public function handleEvent(DomainEventInterface $event): bool { if ($event instanceof MyDomainEvent) { // do something return true; } return false; } } // --- USAGE --- /** @var DomainMessageBusInterface $bus */ $bus = ...; $bus->dispatch(new MyCommand()); ``` [POPO]: https://stackoverflow.com/questions/41188002/what-does-the-term-plain-old-php-object-popo-exactly-mean msgphp-0.4.3/docs/message-driven/message-bus.md000066400000000000000000000014071327361626700214310ustar00rootroot00000000000000# Message Bus A domain message bus is bound to `MsgPhp\Domain\Message\DomainMessageBusInterface`. Its purpose is to dispatch any type of message object and helps you to use [CQRS](cqrs.md) and [event sourcing](../event-sourcing/event-handlers.md). ## API ### `dispatch(object $message): mixed` Dispatches the given message object. The bus can return a value coming from handlers, but is not required to do so. ## Implementations ### `MsgPhp\Domain\Infra\Messenger\DomainMessageBus` A Symfony Messenger tailored domain message bus. - [Read more](../infrastructure/symfony-messenger.md#domain-message-bus) ### `MsgPhp\Domain\Infra\SimpleBus\DomainMessageBus` A SimpleBus tailored domain message bus. - [Read more](../infrastructure/simple-bus.md#domain-message-bus) msgphp-0.4.3/docs/message-driven/message-dispatcher.md000066400000000000000000000015121327361626700227630ustar00rootroot00000000000000# Message Dispatcher The domain message dispatcher is a utility trait. Its purpose is to dispatch a factorized message object using a [object factory](../ddd/factory/object.md) and a [message bus](message-bus.md). ## API ### `dispatch(string $class, array $context = []): mixed` Dispatches a message object factorized from `$class` and `$context`. The dispatcher can return a value coming from handlers, but is not required to do so. ## Basic example ```php argument = $argument; } } class MyClass { use MessageDispatchingTrait; public function doSomething(): void { $this->dispatch(MyMessage::class, ['argument' => 'value']); } } ``` msgphp-0.4.3/docs/projection/000077500000000000000000000000001327361626700161355ustar00rootroot00000000000000msgphp-0.4.3/docs/projection/document-transformers.md000066400000000000000000000033001327361626700230140ustar00rootroot00000000000000# Projection Document Transformers A projection document transformer is bound to `MsgPhp\Domain\Projection\DomainProjectionDocumentTransformerInterface`. Its purpose is to transform domain objects into [projection documents](documents.md). ## API ### `transform(object $object): DomainProjectionDocument` Transforms the domain object into a projection document. ## Basic example ```php id = $id; } } class MyProjection implements DomainProjectionInterface { public $id; public $someField; public static function fromDocument(array $document): DomainProjectionInterface { $projection = new static(); $projection->id = $document['id'] ?? null; $projection->someField = $document['some_field'] ?? null; return $projection; } } class MyTransformer implements DomainProjectionDocumentTransformerInterface { public function transform($object): DomainProjectionDocument { if ($object instanceof MyEntity) { return new DomainProjectionDocument(MyProjection::class, $object->id, [ 'id' => $object->id, 'some_field' => $object->someField, ]); } throw new \LogicException(); } } $transformer = new MyTransformer(); // --- USAGE --- $entity = new MyEntity(1); $document = $transformer->transform($entity); $projection = $document->toProjection(); ``` msgphp-0.4.3/docs/projection/documents.md000066400000000000000000000026301327361626700204610ustar00rootroot00000000000000# Projection Documents A projection document is a domain value object of type `MsgPhp\Domain\Projection\DomainProjectionDocument`. Its purpose is to hold a projection document its data and current state. ## API ### Properties - `int $status`: The current document status. See also [default statuses][api-statuses]. - `?\Throwable $error`: An occurred error, if any - `?object $source`: The origin object source, if any --- ### `getType(): string` Gets the projection type and refers to a [projection](models.md) class name. --- ### `getId(): ?string` Gets the document ID, if any. Otherwise an auto-generated value is implied. --- ### `getBody(): array` Gets the document body. --- ### `toProjection(): DomainProjectionInterface` Transforms the document into its projection model. ## Basic example ```php 'value', ]); /** @var MyProjection $projection */ $projection = $document->toProjection(); ``` [api-statuses]: https://msgphp.github.io/api/MsgPhp/Domain/Projection/DomainProjectionDocument.html#page-content msgphp-0.4.3/docs/projection/models.md000066400000000000000000000027211327361626700177440ustar00rootroot00000000000000# Projections A domain projection is a model object and bound to `MsgPhp\Domain\Projection\DomainProjectionInterface`. Its purpose is to convert raw model data (a document) into a projection, enabling to be stored separate. The document is usually a transformation from a domain object (e.g. an entity) and therefor projections should be considered read-only and disposable, as they can be re-created / synchronized at any time from a source of truth. A practical use case for domain projections are APIs, where each API resource is a so called projection from a corresponding entity. It enables decoupling and thus optimized API responses. !!! info For integration with [API Platform] see the [domain projection data provider](../infrastructure/api-platform.md#domain-projection-data-provider) ## API ### `static fromDocument(array $document): DomainProjectionInterface` Creates a projection from raw document data. ## Basic example ```php someField = $document['some_field'] ?? null; return $projection; } } // --- USAGE --- $projection = MyProjection::fromDocument([ 'some_field' => 'value', ]); ``` [API Platform]: https://api-platform.com/ msgphp-0.4.3/docs/projection/repositories.md000066400000000000000000000035261327361626700212140ustar00rootroot00000000000000# Projection Repositories A domain projection repository is bound to `MsgPhp\Domain\Projection\DomainProjectionRepositoryInterface`. Its purpose is to store and query [projection documents](documents.md). ## API ### `findAll(string $type, int $offset = 0, int $limit = 0): iterable` Finds all [projections](models.md) by type. --- ### `find(string $type, string $id): ?DomainProjectionInterface` Finds a single [projection](models.md) by type and ID. In case its document cannot be found `null` should be returned. --- ### `clear(string $type): void` Deletes all projection documents by type. --- ### `save(DomainProjectionDocument $document): void` Saves a projection document. The document will be available on any subsequent query. --- ### `delete(string $type, string $id): void` Deletes a projection document by type and ID. The document will be unavailable on any subsequent query. ## Implementations ### `MsgPhp\Domain\Infra\Elasticsearch\DomainProjectionRepository` An Elasticsearch tailored projection repository. - [Read more](../infrastructure/elasticsearch.md#domain-projection-repository) ## Basic example ```php find(MyProjection::class, $id); if (null === $projection) { $document = DomainProjectionDocument::create(MyProjection::class, $id, [ 'some_field' => 'value', ]); $repository->save($document); } ``` msgphp-0.4.3/docs/projection/synchronization.md000066400000000000000000000052611327361626700217240ustar00rootroot00000000000000# Projection Synchronization `MsgPhp\Domain\Projection\DomainProjectionSynchronization` is a utility domain service. Its purpose is to ease synchronizing provided [projections](models.md). So called _providers_ actually provide domain objects, which are in turn transformed to [documents](documents.md) using any [transformer](document-transformers.md). A document is then stored using any [repository](repositories.md). ## API ### `synchronize(): iterable` Yields a projection document for each provided domain object regarding its state. The actual document status can be read from [`ProjectionDocument::$status`][api-projection-document-status]. [api-projection-document-status]: https://msgphp.github.io/api/MsgPhp/Domain/Projection/DomainProjectionDocument.html#property_status ## Basic example ```php id = $id; } } /** @var DomainProjectionTypeRegistryInterface $typeRegistry */ $typeRegistry = ...; /** @var DomainProjectionRepositoryInterface $repository */ $repository = ...; /** @var DomainProjectionDocumentTransformerInterface $transformer */ $transformer = ...; $provider = new DomainProjectionDocumentProvider($transformer, [ function (): iterable { yield new MyEntity(1); yield new MyEntity(2); }, ]); $synchronization = new DomainProjectionSynchronization($typeRegistry, $repository, $provider); // --- USAGE --- foreach ($synchronization->synchronize() as $document) { if (DomainProjectionDocument::STATUS_SYNCHRONIZED === $document->status) { echo 'Synchronized projection for '.get_class($document->source).' with ID '.$document->source->id.PHP_EOL; continue; } echo 'Invalid projection for '.get_class($document->source).' with ID '.$document->source->id.PHP_EOL; if (null !== $document->error) { echo 'An error occurred for '.get_class($document->source).' with ID '.$document->source->id.PHP_EOL; echo $document->error->getMessage().' in '.$document->error->getFile().' at '.$document->error->getLine().PHP_EOL; } } ``` ## Command Line Interface A synchronization can be ran using the CLI when working with Symfony Console. - [Read more](../infrastructure/symfony-console.md#synchronizedomainprojectionscommand) msgphp-0.4.3/docs/projection/type-registry.md000066400000000000000000000025021327361626700213050ustar00rootroot00000000000000# Projection Type Registry A projection type registry is bound to `MsgPhp\Domain\Projection\DomainProjectionTypeRegistryInterface`. Its purpose is to manage all available [projection](models.md) type information. ## API ### `all(): string[]` Returns all available projection types for this registry. --- ### `initialize(): void` Initializes the type registry. Usually needs to be called only once per environment, or after any type information has changed. --- ### `destroy(): void` Destroys the type registry and thus requires to be re-initialized after. ## Implementations ### `MsgPhp\Domain\Infra\Elasticsearch\DomainProjectionTypeRegistry` An Elasticsearch tailored projection type registry. - [Read more](../infrastructure/elasticsearch.md#domain-projection-type-registry) ## Basic example ```php destroy(); $typeRegistry->initialize(); echo 'Initialized types: '.implode(', ', $typeRegistry->all()); ``` ## Command Line Interface The type registry can be initialized using the CLI when working with Symfony Console. - [Read more](../infrastructure/symfony-console.md#initializedomainprojectiontypescommand) msgphp-0.4.3/docs/reference/000077500000000000000000000000001327361626700157175ustar00rootroot00000000000000msgphp-0.4.3/docs/reference/doctrine-identifier-types.md000066400000000000000000000012471327361626700233360ustar00rootroot00000000000000# Doctrine Identifier Types Reference of available [Doctrine identifier types](../infrastructure/doctrine-dbal.md#domain-identifier-type) per domain. ## `msgphp/domain` Type name | Type class --- | --- `msgphp_domain_id` | `MsgPhp\Domain\Infra\Doctrine\DomainIdType` ## `msgphp/eav` Type name | Type class --- | --- `msgphp_attribute_id` | `MsgPhp\Eav\Infra\Doctrine\Type\AttributeIdType` `msgphp_attribute_value_id` | `MsgPhp\Eav\Infra\Doctrine\Type\AttributeValueIdType` ## `msgphp/user` Type name | Type class --- | --- `msgphp_user_id` | `MsgPhp\User\Infra\Doctrine\Type\UserIdType` msgphp-0.4.3/docs/reference/entities.md000066400000000000000000000032271327361626700200710ustar00rootroot00000000000000# Domain Entities Reference of available [entities](../ddd/entities.md) per domain. ## `msgphp/domain` ### Entity Fields - `MsgPhp\Domain\Entity\Fields\CreatedAtField` - `MsgPhp\Domain\Entity\Fields\EnabledField` - `MsgPhp\Domain\Entity\Fields\LastUpdatedAtField` ### Entity Features - `MsgPhp\Domain\Entity\Features\CanBeConfirmed` - `MsgPhp\Domain\Entity\Features\CanBeEnabled` ## `msgphp/eav` ### Entities Class | Abstract --- | --- `MsgPhp\Eav\Entity\Attribute` | ✔ `MsgPhp\Eav\Entity\AttributeValue` | ✔ ### Entity Fields - `MsgPhp\Eav\Entity\Fields\AttributesField` ### Entity Features - `MsgPhp\Eav\Entity\Features\EntityAttributeValue` ## `msgphp/user` ### Entities Class | Abstract --- | --- `MsgPhp\User\Entity\Role` | ✔ `MsgPhp\User\Entity\User` | ✔ `MsgPhp\User\Entity\UserAttributeValue` | ✔ `MsgPhp\User\Entity\UserEmail` | ✔ `MsgPhp\User\Entity\UserRole` | ✔ `MsgPhp\User\Entity\Username` | ✗ ### Entity Fields - `MsgPhp\User\Entity\Fields\AttributeValuesField` - `MsgPhp\User\Entity\Fields\EmailsField` - `MsgPhp\User\Entity\Fields\RoleField` - `MsgPhp\User\Entity\Fields\RolesField` - `MsgPhp\User\Entity\Fields\UserField` ### Entity Features - `MsgPhp\User\Entity\Features\EmailCredential` - `MsgPhp\User\Entity\Features\EmailPasswordCredential` - `MsgPhp\User\Entity\Features\EmailSaltedPasswordCredential` - `MsgPhp\User\Entity\Features\NicknameCredential` - `MsgPhp\User\Entity\Features\NicknamePasswordCredential` - `MsgPhp\User\Entity\Features\NicknameSaltedPasswordCredential` - `MsgPhp\User\Entity\Features\ResettablePassword` - `MsgPhp\User\Entity\Features\TokenCredential` msgphp-0.4.3/docs/reference/identifiers.md000066400000000000000000000015151327361626700205500ustar00rootroot00000000000000# Domain Identifiers Reference of available [identifiers](../ddd/identifiers.md) per domain. ## `msgphp/domain` ### `MsgPhp\Domain\DomainIdInterface` Primitive type | Implementation --- | --- Scalar | `MsgPhp\Domain\DomainId` UUID | `MsgPhp\Domain\Infra\Uuid\DomainId` ## `msgphp/eav` ### `MsgPhp\Eav\AttributeIdInterface` Primitive type | Implementation --- | --- Scalar | `MsgPhp\Eav\AttributeId` UUID | `MsgPhp\Eav\Infra\Uuid\AttributeId` ### `MsgPhp\Eav\AttributeValueIdInterface` Primitive type | Implementation --- | --- Scalar | `MsgPhp\Eav\AttributeValueId` UUID | `MsgPhp\Eav\Infra\Uuid\AttributeValueId` ## `msgphp/user` ### `MsgPhp\User\UserIdInterface` Primitive type | Implementation --- | --- Scalar | `MsgPhp\User\UserId` UUID | `MsgPhp\User\Infra\Uuid\UserId` msgphp-0.4.3/mkdocs.yml000066400000000000000000000045121327361626700150360ustar00rootroot00000000000000site_name: MsgPHP Documentation site_description: Message based domain layers. Shipped with industry standard infrastructure. repo_url: https://github.com/msgphp/msgphp edit_uri: blob/master/docs/ site_dir: var/docs/build/ theme: name: material custom_dir: docs/.theme extra_css: [style.css] markdown_extensions: - codehilite # https://squidfunk.github.io/mkdocs-material/extensions/codehilite/ - admonition # https://squidfunk.github.io/mkdocs-material/extensions/admonition/ pages: - Home: index.md - Code Conventions: code-conventions.md - Domain-Driven-Design: - Identifiers: ddd/identifiers.md - Identities: ddd/identities.md - Identity Mapping: ddd/identity-mapping.md - Collections: ddd/collections.md - Factories: - Object Factory: ddd/factory/object.md - Entity Aware Factory: ddd/factory/entity-aware.md - Static Factory: ddd/factory/static.md - Repositories: ddd/repositories.md - Entities: ddd/entities.md - Event-Sourcing: - Events: event-sourcing/events.md - Event Handlers: event-sourcing/event-handlers.md - Message Driven: - Message Bus: message-driven/message-bus.md - Message Dispatcher: message-driven/message-dispatcher.md - CQRS: message-driven/cqrs.md - Projection: - Models: projection/models.md - Documents: projection/documents.md - Document Transformers: projection/document-transformers.md - Type Registry: projection/type-registry.md - Repositories: projection/repositories.md - Synchronization: projection/synchronization.md - Infrastructure: - API Platform: infrastructure/api-platform.md - Doctrine Collections: infrastructure/doctrine-collections.md - Doctrine DBAL: infrastructure/doctrine-dbal.md - Doctrine ORM: infrastructure/doctrine-orm.md - Elasticsearch: infrastructure/elasticsearch.md - SimpleBus: infrastructure/simple-bus.md - Symfony Console: infrastructure/symfony-console.md - Symfony Messenger: infrastructure/symfony-messenger.md - UUID: infrastructure/uuid.md - Cookbook: - Bundle Installation: cookbook/bundle-installation.md - Configuring Doctrine ORM: cookbook/configuring-doctrine-orm.md - Reference: - Domain Identifiers: reference/identifiers.md - Domain Entities: reference/entities.md - Doctrine Identifier Types: reference/doctrine-identifier-types.md msgphp-0.4.3/phpstan.neon000066400000000000000000000032151327361626700153700ustar00rootroot00000000000000includes: - vendor/phpstan/phpstan-phpunit/extension.neon - vendor/phpstan/phpstan-phpunit/rules.neon - vendor/phpstan/phpstan-phpunit/strictRules.neon parameters: ignoreErrors: - '#Constructor of class MsgPhp\\Domain\\Tests\\Factory\\KnownTestObject has an unused parameter \$arg\.#' - '#Parameter \$arg of method MsgPhp\\Domain\\Tests\\Factory\\KnownTestObject::__construct\(\) has invalid typehint type MsgPhp\\Domain\\Tests\\Factory\\UnknownTestObject\.#' - '#Static property MsgPhp\\Domain\\Tests\\Infra\\InMemory\\DomainEntityRepositoryTraitTest::\$memory \(MsgPhp\\Domain\\Infra\\InMemory\\GlobalObjectMemory\) does not accept null\.#' - '#Class MsgPhp\\Domain\\Tests\\Factory\\WrongCase referenced with incorrect case: MsgPhp\\Domain\\Tests\\Factory\\wrongcase\.#' # forward compatibility - '#Class MsgPhp\\Domain\\Infra\\Config\\ClassMappingNode constructor invoked with 3 parameters, 1\-2 required\.#' - '#Access to an undefined property MsgPhp\\Domain\\Infra\\Config\\ClassMappingNodeDefinition::\$pathSeparator#' # symfony fluent config - '#Call to an undefined method Symfony\\Component\\Config\\Definition\\Builder\\NodeParentInterface::classMappingNode\(\)\.#' - '#Calling method classMappingNode\(\) on possibly null value of type Symfony\\Component\\Config\\Definition\\Builder\\NodeParentInterface\|null\.#' excludes_analyse: - '*/vendor/*' - src/UserBundle/Resources/skeleton/ # see https://github.com/phpstan/phpstan/issues/859 - src/UserBundle/Maker/UserMaker.php - src/UserBundle/Resources/config/services.php msgphp-0.4.3/src/000077500000000000000000000000001327361626700136205ustar00rootroot00000000000000msgphp-0.4.3/src/Domain/000077500000000000000000000000001327361626700150275ustar00rootroot00000000000000msgphp-0.4.3/src/Domain/.gitattributes000066400000000000000000000000641327361626700177220ustar00rootroot00000000000000Tests/ export-ignore phpunit.xml.dist export-ignore msgphp-0.4.3/src/Domain/.gitignore000066400000000000000000000000471327361626700170200ustar00rootroot00000000000000/composer.lock /composer.phar /vendor/ msgphp-0.4.3/src/Domain/Command/000077500000000000000000000000001327361626700164055ustar00rootroot00000000000000msgphp-0.4.3/src/Domain/Command/EventSourcingCommandHandlerTrait.php000066400000000000000000000021711327361626700255130ustar00rootroot00000000000000 */ trait EventSourcingCommandHandlerTrait { /** * @param object $command */ private function handle($command, callable $onHandled = null): void { $event = $this->getDomainEvent($command); $handler = $this->getDomainEventHandler($command); if (!$handler instanceof DomainEventHandlerInterface) { throw new \LogicException(sprintf('Object "%s" is unable to handle domain event "%s". Did you forgot to implement DomainEventHandlerInterface?', get_class($handler), get_class($event))); } if ($handler->handleEvent($event) && null !== $onHandled) { $onHandled($handler); } } /** * @param object $command */ abstract protected function getDomainEvent($command): DomainEventInterface; /** * @param object $command */ abstract protected function getDomainEventHandler($command): DomainEventHandlerInterface; } msgphp-0.4.3/src/Domain/DomainCollection.php000066400000000000000000000106241327361626700207660ustar00rootroot00000000000000 */ final class DomainCollection implements DomainCollectionInterface { private $elements; /** * @return $this|self */ public static function fromValue(?iterable $value): DomainCollectionInterface { return new self($value ?? []); } public function __construct(iterable $elements) { $this->elements = $elements; } public function getIterator(): \Traversable { if ($this->elements instanceof \Traversable) { return (function () { foreach ($this->elements as $key => $element) { yield $key => $element; } })(); } return new \ArrayIterator($this->elements); } public function isEmpty(): bool { if ($this->elements instanceof \Traversable) { foreach ($this->elements as $element) { return false; } return true; } return !$this->elements; } public function contains($element): bool { if ($this->elements instanceof \Traversable) { foreach ($this->elements as $key => $knownElement) { if ($element === $knownElement) { return true; } } return false; } return in_array($element, $this->elements, true); } public function containsKey($key): bool { if ($this->elements instanceof \Traversable) { foreach ($this->elements as $knownKey => $element) { if ((string) $key === (string) $knownKey) { return true; } } return false; } return isset($this->elements[$key]) || array_key_exists($key, $this->elements); } public function first() { if ($this->elements instanceof \Traversable) { foreach ($this->elements as $element) { return $element; } return false; } return reset($this->elements); } public function last() { if ($this->elements instanceof \Traversable) { $element = false; foreach ($this->elements as $key => $element) { } return $element; } return end($this->elements); } public function get($key) { if ($this->elements instanceof \Traversable) { foreach ($this->elements as $knownKey => $element) { if ((string) $key === (string) $knownKey) { return $element; } } return null; } return $this->elements[$key] ?? null; } public function filter(callable $filter): DomainCollectionInterface { if ($this->elements instanceof \Traversable) { $elements = []; foreach ($this->elements as $key => $element) { if ($filter($element)) { $elements[$key] = $element; } } return new self($elements); } return new self(array_filter($this->elements, $filter)); } public function slice(int $offset, int $limit = 0): DomainCollectionInterface { if ($this->elements instanceof \Traversable) { $elements = []; $i = -1; foreach ($this->elements as $key => $element) { if (++$i < $offset) { continue; } if ($limit && $i >= ($offset + $limit)) { break; } $elements[$key] = $element; } return new self($elements); } return new self(array_slice($this->elements, $offset, $limit ?: null, true)); } public function map(callable $mapper): array { if ($this->elements instanceof \Traversable) { $elements = []; foreach ($this->elements as $key => $element) { $elements[$key] = $mapper($element); } return $elements; } return array_map($mapper, $this->elements); } public function count(): int { return $this->elements instanceof \Traversable ? iterator_count($this->elements) : count($this->elements); } } msgphp-0.4.3/src/Domain/DomainCollectionInterface.php000066400000000000000000000013501327361626700226030ustar00rootroot00000000000000 */ interface DomainCollectionInterface extends \Countable, \IteratorAggregate { public static function fromValue(?iterable $value): self; public function isEmpty(): bool; public function contains($element): bool; /** * @param string|int $key */ public function containsKey($key): bool; public function first(); public function last(); /** * @param string|int $key */ public function get($key); public function filter(callable $filter): self; public function slice(int $offset, int $limit = 0): self; public function map(callable $mapper): array; } msgphp-0.4.3/src/Domain/DomainId.php000066400000000000000000000025001327361626700172210ustar00rootroot00000000000000 */ class DomainId implements DomainIdInterface { private $id; /** * @return $this|self */ final public static function fromValue($value): DomainIdInterface { if (null !== $value && !is_string($value)) { $value = (string) $value; } return new static($value); } final public function __construct(string $id = null) { $this->id = $id; } final public function isEmpty(): bool { return null === $this->id; } final public function equals(DomainIdInterface $id): bool { return $id === $this ? true : (null !== $this->id && $id instanceof self && static::class === get_class($id) ? $this->id === $id->id : false); } final public function toString(): string { return $this->id ?? ''; } final public function __toString(): string { return $this->id ?? ''; } final public function serialize(): string { return serialize($this->id); } final public function unserialize($serialized): void { $this->id = unserialize($serialized); } final public function jsonSerialize(): ?string { return $this->id; } } msgphp-0.4.3/src/Domain/DomainIdInterface.php000066400000000000000000000006361327361626700210520ustar00rootroot00000000000000 */ interface DomainIdInterface extends \Serializable, \JsonSerializable { public static function fromValue($value): self; public function isEmpty(): bool; public function equals(self $id): bool; public function toString(): string; public function __toString(): string; } msgphp-0.4.3/src/Domain/DomainIdentityHelper.php000066400000000000000000000067271327361626700216350ustar00rootroot00000000000000 */ final class DomainIdentityHelper { private $mapping; public function __construct(DomainIdentityMappingInterface $mapping) { $this->mapping = $mapping; } public function isIdentifier($value): bool { if ($value instanceof DomainIdInterface) { return true; } if (is_object($value)) { try { $this->mapping->getIdentifierFieldNames(get_class($value)); return true; } catch (InvalidClassException $e) { } } return false; } public function isEmptyIdentifier($value): bool { if (null === $value) { return true; } if ($value instanceof DomainIdInterface) { return $value->isEmpty(); } if (is_object($value)) { try { $identity = $this->mapping->getIdentity($value); } catch (InvalidClassException $e) { return false; } return !$this->isIdentity(get_class($value), $identity); } return false; } public function normalizeIdentifier($value) { if ($value instanceof DomainIdInterface) { return $value->isEmpty() ? null : $value->toString(); } if (is_object($value)) { try { $identity = $this->mapping->getIdentity($value); } catch (InvalidClassException $e) { return $value; } $identity = array_map(function ($id) { return $this->normalizeIdentifier($id); }, $identity); return 1 === count($this->mapping->getIdentifierFieldNames(get_class($value))) ? reset($identity) : $identity; } return $value; } /** * @param object $object */ public function getIdentifiers($object): array { return null === ($identity = $this->mapping->getIdentity($object)) ? [] : array_values($identity); } /** * @return string[] */ public function getIdentifierFieldNames(string $class): array { return $this->mapping->getIdentifierFieldNames($class); } public function isIdentity(string $class, $value): bool { if (null === $value || [] === $value) { return false; } $fields = $this->mapping->getIdentifierFieldNames($class); $count = count($fields); if (is_array($value)) { if (count($value) !== $count) { return false; } if (($oldValue = $value) !== $value = array_filter($value, function ($value): bool { return !$this->isEmptyIdentifier($value); })) { return false; } return !array_diff_key($value, array_flip($fields)); } return 1 === $count && !$this->isEmptyIdentifier($value); } public function toIdentity(string $class, $value): array { if (is_array($value)) { return $value; } $fields = $this->mapping->getIdentifierFieldNames($class); return [reset($fields) => $value]; } /** * @param object $object */ public function getIdentity($object): array { return $this->mapping->getIdentity($object); } } msgphp-0.4.3/src/Domain/DomainIdentityMappingInterface.php000066400000000000000000000005611327361626700236200ustar00rootroot00000000000000 */ interface DomainIdentityMappingInterface { /** * @return string[] */ public function getIdentifierFieldNames(string $class): array; /** * @param object $object */ public function getIdentity($object): array; } msgphp-0.4.3/src/Domain/Entity/000077500000000000000000000000001327361626700163035ustar00rootroot00000000000000msgphp-0.4.3/src/Domain/Entity/Features/000077500000000000000000000000001327361626700200615ustar00rootroot00000000000000msgphp-0.4.3/src/Domain/Entity/Features/CanBeConfirmed.php000066400000000000000000000017431327361626700233760ustar00rootroot00000000000000 */ trait CanBeConfirmed { /** @var string|null */ private $confirmationToken; /** @var \DateTimeInterface|null */ private $confirmedAt; public function getConfirmationToken(): ?string { return $this->confirmationToken; } public function getConfirmedAt(): ?\DateTimeInterface { return $this->confirmedAt; } public function isConfirmed(): bool { return null !== $this->confirmedAt; } public function confirm(): void { $this->confirmationToken = null; $this->confirmedAt = new \DateTimeImmutable(); } private function handleConfirmEvent(ConfirmEvent $event): bool { if (null === $this->confirmedAt) { $this->confirm(); return true; } return false; } } msgphp-0.4.3/src/Domain/Entity/Features/CanBeEnabled.php000066400000000000000000000015071327361626700230200ustar00rootroot00000000000000 */ trait CanBeEnabled { use EnabledField; public function enable(): void { $this->enabled = true; } public function disable(): void { $this->enabled = false; } private function handleEnableEvent(EnableEvent $event): bool { if (!$this->enabled) { $this->enable(); return true; } return false; } private function handleDisableEvent(DisableEvent $event): bool { if ($this->enabled) { $this->disable(); return true; } return false; } } msgphp-0.4.3/src/Domain/Entity/Fields/000077500000000000000000000000001327361626700175115ustar00rootroot00000000000000msgphp-0.4.3/src/Domain/Entity/Fields/CreatedAtField.php000066400000000000000000000005011327361626700230160ustar00rootroot00000000000000 */ trait CreatedAtField { /** @var \DateTimeInterface */ private $createdAt; public function getCreatedAt(): \DateTimeInterface { return $this->createdAt; } } msgphp-0.4.3/src/Domain/Entity/Fields/EnabledField.php000066400000000000000000000004441327361626700225220ustar00rootroot00000000000000 */ trait EnabledField { /** @var bool */ private $enabled = false; public function isEnabled(): bool { return $this->enabled; } } msgphp-0.4.3/src/Domain/Entity/Fields/LastUpdatedAtField.php000066400000000000000000000005211327361626700236630ustar00rootroot00000000000000 */ trait LastUpdatedAtField { /** @var \DateTimeInterface */ private $lastUpdatedAt; public function getLastUpdatedAt(): \DateTimeInterface { return $this->lastUpdatedAt; } } msgphp-0.4.3/src/Domain/Event/000077500000000000000000000000001327361626700161105ustar00rootroot00000000000000msgphp-0.4.3/src/Domain/Event/ConfirmEvent.php000066400000000000000000000002671327361626700212250ustar00rootroot00000000000000 */ class ConfirmEvent implements DomainEventInterface { } msgphp-0.4.3/src/Domain/Event/DisableEvent.php000066400000000000000000000002671327361626700211730ustar00rootroot00000000000000 */ class DisableEvent implements DomainEventInterface { } msgphp-0.4.3/src/Domain/Event/DomainEventHandlerInterface.php000066400000000000000000000003561327361626700241550ustar00rootroot00000000000000 */ interface DomainEventHandlerInterface { public function handleEvent(DomainEventInterface $event): bool; } msgphp-0.4.3/src/Domain/Event/DomainEventHandlerTrait.php000066400000000000000000000012641327361626700233370ustar00rootroot00000000000000 */ trait DomainEventHandlerTrait { public function handleEvent(DomainEventInterface $event): bool { $method = 'handle'.(false === ($pos = strrpos($class = get_class($event), '\\')) ? $class : substr($class, $pos + 1)); if ('Event' !== substr($method, -5)) { $method .= 'Event'; } if (!method_exists($this, $method)) { throw UnknownDomainEventException::createForHandler($this, $event); } return $this->$method($event); } } msgphp-0.4.3/src/Domain/Event/DomainEventInterface.php000066400000000000000000000002431327361626700226520ustar00rootroot00000000000000 */ interface DomainEventInterface { } msgphp-0.4.3/src/Domain/Event/EnableEvent.php000066400000000000000000000002661327361626700210150ustar00rootroot00000000000000 */ class EnableEvent implements DomainEventInterface { } msgphp-0.4.3/src/Domain/Exception/000077500000000000000000000000001327361626700167655ustar00rootroot00000000000000msgphp-0.4.3/src/Domain/Exception/DomainExceptionInterface.php000066400000000000000000000002531327361626700244050ustar00rootroot00000000000000 */ interface DomainExceptionInterface { } msgphp-0.4.3/src/Domain/Exception/DuplicateEntityException.php000066400000000000000000000006541327361626700244710ustar00rootroot00000000000000 */ final class DuplicateEntityException extends \RuntimeException implements DomainExceptionInterface { public static function createForId(string $class, $id): self { return new self(sprintf('Entity "%s" with identifier %s cannot be duplicated.', $class, json_encode($id))); } } msgphp-0.4.3/src/Domain/Exception/EntityNotFoundException.php000066400000000000000000000011721327361626700243070ustar00rootroot00000000000000 */ final class EntityNotFoundException extends \RuntimeException implements DomainExceptionInterface { public static function createForId(string $class, $id): self { return new self(sprintf('Entity "%s" with identifier %s cannot be found.', $class, json_encode($id))); } public static function createForFields(string $class, array $fields): self { return new self(sprintf('Entity "%s" with fields matching %s cannot be found.', $class, json_encode($fields))); } } msgphp-0.4.3/src/Domain/Exception/InvalidClassException.php000066400000000000000000000010631327361626700237310ustar00rootroot00000000000000 */ final class InvalidClassException extends \LogicException implements DomainExceptionInterface { public static function create(string $class): self { return new self(sprintf('Invalid class "%s" detected.', $class)); } public static function createForMethod(string $class, string $method): self { return new self(sprintf('Invalid class "%s" detected for method "%s".', $class, $method)); } } msgphp-0.4.3/src/Domain/Exception/UnknownDomainEventException.php000066400000000000000000000010671327361626700251520ustar00rootroot00000000000000 */ final class UnknownDomainEventException extends \RuntimeException implements DomainExceptionInterface { public static function createForHandler(DomainEventHandlerInterface $handler, DomainEventInterface $event): self { return new self(sprintf('Domain event "%s" cannot be handled by "%s".', get_class($event), get_class($handler))); } } msgphp-0.4.3/src/Domain/Factory/000077500000000000000000000000001327361626700164365ustar00rootroot00000000000000msgphp-0.4.3/src/Domain/Factory/ChainObjectFactory.php000066400000000000000000000014261327361626700226530ustar00rootroot00000000000000 */ final class ChainObjectFactory implements DomainObjectFactoryInterface { private $factories; /** * @param DomainObjectFactoryInterface[] $factories */ public function __construct(iterable $factories) { $this->factories = $factories; } public function create(string $entity, array $context = []) { foreach ($this->factories as $factory) { try { return $factory->create($entity, $context); } catch (InvalidClassException $e) { } } throw InvalidClassException::create($entity); } } msgphp-0.4.3/src/Domain/Factory/ClassMappingObjectFactory.php000066400000000000000000000011111327361626700242010ustar00rootroot00000000000000 */ final class ClassMappingObjectFactory implements DomainObjectFactoryInterface { private $factory; private $mapping; public function __construct(DomainObjectFactoryInterface $factory, array $mapping) { $this->factory = $factory; $this->mapping = $mapping; } public function create(string $class, array $context = []) { return $this->factory->create($this->mapping[$class] ?? $class, $context); } } msgphp-0.4.3/src/Domain/Factory/ClassMethodResolver.php000066400000000000000000000044471327361626700231100ustar00rootroot00000000000000 */ final class ClassMethodResolver { private static $cache = []; public static function resolve(string $class, string $method): array { if (isset(self::$cache[$key = $class.'::'.$method])) { return self::$cache[$key]; } try { $reflection = new \ReflectionClass($class); $reflection = '__construct' === $method ? $reflection->getConstructor() : $reflection->getMethod($method); } catch (\ReflectionException $e) { throw InvalidClassException::createForMethod($class, $method); } if (null === $reflection) { return self::$cache[$key] = []; } return self::$cache[$key] = array_map(function (\ReflectionParameter $param): array { $type = $param->getType(); if (null !== $type) { if ('self' === strtolower($name = $type->getName())) { $type = $param->getClass()->getName(); } elseif ($type->isBuiltin()) { $type = $name; } else { try { $type = (new \ReflectionClass($name))->getName(); } catch (\ReflectionException $e) { $type = $name; } } } $required = false; if ($param->isDefaultValueAvailable()) { $default = $param->getDefaultValue(); } elseif ($param->allowsNull()) { $default = null; } elseif ('array' === $type || 'iterable' === $type) { $default = []; $required = true; } else { $default = null; $required = true; } return [ 'name' => $name = $param->getName(), 'key' => strtolower(preg_replace(['/([A-Z]+)([A-Z][a-z])/', '/([a-z\d])([A-Z])/'], ['\\1_\\2', '\\1_\\2'], $name)), 'required' => $required, 'default' => $default, 'type' => $type, ]; }, $reflection->getParameters()); } } msgphp-0.4.3/src/Domain/Factory/DomainCollectionFactory.php000066400000000000000000000013411327361626700237210ustar00rootroot00000000000000 */ final class DomainCollectionFactory { public static function create(?iterable $value): DomainCollectionInterface { if ($value instanceof DomainCollectionInterface) { return $value; } if ($value instanceof Collection) { return new DoctrineInfra\DomainCollection($value); } return DomainCollection::fromValue($value); } private function __construct() { } } msgphp-0.4.3/src/Domain/Factory/DomainIdFactory.php000066400000000000000000000014461327361626700221700ustar00rootroot00000000000000 */ final class DomainIdFactory { public static function create($value): DomainIdInterface { if ($value instanceof DomainIdInterface) { return $value; } if ($value instanceof UuidInterface) { return new UuidInfra\DomainId($value); } if (class_exists(Uuid::class) && Uuid::isValid($value)) { return UuidInfra\DomainId::fromValue($value); } return DomainId::fromValue($value); } private function __construct() { } } msgphp-0.4.3/src/Domain/Factory/DomainObjectFactory.php000066400000000000000000000044241327361626700230410ustar00rootroot00000000000000 */ final class DomainObjectFactory implements DomainObjectFactoryInterface { private $factory; public function setNestedFactory(?DomainObjectFactoryInterface $factory): void { $this->factory = $factory; } public function create(string $class, array $context = []) { if (is_subclass_of($class, DomainIdInterface::class) || is_subclass_of($class, DomainCollectionInterface::class)) { return $class::fromValue(...$this->resolveArguments($class, 'fromValue', $context)); } if (!class_exists($class)) { throw InvalidClassException::create($class); } return new $class(...$this->resolveArguments($class, '__construct', $context)); } private function resolveArguments(string $class, string $method, array $context): array { $arguments = []; foreach (ClassMethodResolver::resolve($class, $method) as $i => $argument) { $given = true; if (array_key_exists($name = $argument['name'], $context)) { $value = $context[$name]; } elseif (array_key_exists($key = $argument['key'], $context)) { $value = $context[$key]; } elseif (array_key_exists($i, $context)) { $value = $context[$i]; } elseif (!$argument['required']) { $value = $argument['default']; $given = false; } else { throw new \LogicException(sprintf('No value available for argument $%s in class method "%s::%s()".', $name, $class, $method)); } if ($given && isset($argument['type']) && (interface_exists($argument['type']) || class_exists($argument['type'])) && !is_object($value)) { try { $arguments[] = ($this->factory ?? $this)->create($argument['type'], (array) $value); continue; } catch (InvalidClassException $e) { } } $arguments[] = $value; } return $arguments; } } msgphp-0.4.3/src/Domain/Factory/DomainObjectFactoryInterface.php000066400000000000000000000004231327361626700246550ustar00rootroot00000000000000 */ interface DomainObjectFactoryInterface { /** * @return object */ public function create(string $class, array $context = []); } msgphp-0.4.3/src/Domain/Factory/EntityAwareFactory.php000066400000000000000000000035521327361626700227400ustar00rootroot00000000000000 */ final class EntityAwareFactory implements EntityAwareFactoryInterface { private $factory; private $identityMapping; private $identifierMapping; public function __construct(DomainObjectFactoryInterface $factory, DomainIdentityMappingInterface $identityMapping, array $identifierMapping = []) { $this->factory = $factory; $this->identityMapping = $identityMapping; $this->identifierMapping = $identifierMapping; } public function create(string $class, array $context = []) { return $this->factory->create($class, $context); } public function reference(string $class, $id) { $idFields = $this->identityMapping->getIdentifierFieldNames($class); if (!is_array($id)) { $id = [array_shift($idFields) => $id]; } return $this->factory->create($class, $id + array_fill_keys($idFields, null)); } public function identify(string $class, $value): DomainIdInterface { if ($value instanceof DomainIdInterface) { return $value; } $object = $this->factory->create($this->identifierMapping[$class] ?? $class, [$value]); if (!$object instanceof DomainIdInterface) { throw InvalidClassException::create($class); } return $object; } public function nextIdentifier(string $class): DomainIdInterface { $object = $this->factory->create($this->identifierMapping[$class] ?? $class); if (!$object instanceof DomainIdInterface) { throw InvalidClassException::create($class); } return $object; } } msgphp-0.4.3/src/Domain/Factory/EntityAwareFactoryInterface.php000066400000000000000000000007401327361626700245550ustar00rootroot00000000000000 */ interface EntityAwareFactoryInterface extends DomainObjectFactoryInterface { /** * @return object */ public function reference(string $class, $id); public function identify(string $class, $value): DomainIdInterface; public function nextIdentifier(string $class): DomainIdInterface; } msgphp-0.4.3/src/Domain/Infra/000077500000000000000000000000001327361626700160665ustar00rootroot00000000000000msgphp-0.4.3/src/Domain/Infra/ApiPlatform/000077500000000000000000000000001327361626700203045ustar00rootroot00000000000000msgphp-0.4.3/src/Domain/Infra/ApiPlatform/DomainProjectionDataProvider.php000066400000000000000000000030011327361626700265600ustar00rootroot00000000000000 */ final class DomainProjectionDataProvider implements CollectionDataProviderInterface, ItemDataProviderInterface, RestrictedDataProviderInterface { private $typeRegistry; private $repository; public function __construct(DomainProjectionTypeRegistryInterface $typeRegistry, DomainProjectionRepositoryInterface $repository) { $this->typeRegistry = $typeRegistry; $this->repository = $repository; } public function supports(string $resourceClass, string $operationName = null, array $context = []): bool { return in_array($resourceClass, $this->typeRegistry->all(), true); } /** * @return DomainProjectionInterface[] */ public function getCollection(string $resourceClass, string $operationName = null): iterable { return $this->repository->findAll($resourceClass); } public function getItem(string $resourceClass, $id, string $operationName = null, array $context = []): ?DomainProjectionInterface { return $this->repository->find($resourceClass, $id); } } msgphp-0.4.3/src/Domain/Infra/Config/000077500000000000000000000000001327361626700172735ustar00rootroot00000000000000msgphp-0.4.3/src/Domain/Infra/Config/ClassMappingNode.php000066400000000000000000000023021327361626700231700ustar00rootroot00000000000000 */ final class ClassMappingNode extends PrototypedArrayNode { public function setAllowEmptyValue($allowEmptyValue): void { $this->setMinNumberOfElements($allowEmptyValue ? 0 : 1); } protected function validateType($value): void { parent::validateType($value); if (!is_array($value)) { throw new \UnexpectedValueException(sprintf('Expected configuration value to be type array, got "%s".', gettype($value))); } foreach ($value as $k => $v) { if (class_exists($k) || interface_exists($k)) { continue; } $e = new InvalidConfigurationException(sprintf('A class or interface named "%s" does not exists at path "%s".', $k, $this->getPath())); $e->setPath($this->getPath()); if ($hint = $this->getInfo()) { $e->addHint($hint); } throw $e; } } } msgphp-0.4.3/src/Domain/Infra/Config/ClassMappingNodeDefinition.php000066400000000000000000000134611327361626700252110ustar00rootroot00000000000000 */ final class ClassMappingNodeDefinition extends VariableNodeDefinition implements ParentNodeDefinitionInterface { public const NAME = 'class_mapping'; /** @var BaseNodeBuilder|null */ private $builder; private $prototype; private $type = 'scalar'; public function requireClasses(array $classes): self { foreach ($classes as $class) { $this->validate() ->ifTrue(function (array $value) use ($class): bool { return !isset($value[$class]); }) ->thenInvalid(sprintf('Class "%s" must be configured.', $class)); } if ($classes) { $this->isRequired(); } return $this; } public function disallowClasses(array $classes): self { foreach ($classes as $class) { $this->validate() ->ifTrue(function (array $value) use ($class): bool { return isset($value[$class]); }) ->thenInvalid(sprintf('Class "%s" is not applicable to be configured.', $class)); } return $this; } public function groupClasses(array $classes): self { $this->validate()->always(function (array $value) use ($classes): array { if ($classes !== ($missing = array_diff($classes, array_keys($value))) && $missing) { foreach (array_diff($classes, $missing) as $known) { throw new \LogicException(sprintf('Class "%s" requires "%s" to be configured.', $known, implode('", "', $missing))); } } return $value; }); return $this; } public function typeOfValues(string $type): self { $this->type = $type; return $this; } public function subClassValues(): self { $this->validate()->always(function (array $value): array { foreach ($value as $class => $mappedClass) { if (!is_string($mappedClass)) { throw new \LogicException(sprintf('Class "%s" must be configured to a mapped sub class value, got type "%s".', $class, gettype($mappedClass))); } if (!is_subclass_of($mappedClass, $class)) { throw new \LogicException(sprintf('Class "%s" must be configured to a mapped sub class value, got "%s".', $class, $mappedClass)); } } return $value; }); return $this; } public function subClassKeys(array $classes): self { $this->validate()->always(function (array $value) use ($classes): array { foreach ($value as $class => $classValue) { foreach ($classes as $subClass) { if (!is_subclass_of($class, $subClass)) { throw new \LogicException(sprintf('Class "%s" must be a sub class of "%s".', $class, $subClass)); } } } return $value; }); return $this; } public function defaultMapping(array $mapping): self { $this->defaultValue($mapping); $this->validate()->always(function (array $value) use ($mapping): array { return $value + $mapping; }); return $this; } public function children(): BaseNodeBuilder { throw new \BadMethodCallException(sprintf('Method "%s" is not applicable.', __METHOD__)); } public function append(NodeDefinition $node): self { throw new \BadMethodCallException(sprintf('Method "%s" is not applicable.', __METHOD__)); } public function getChildNodeDefinitions(): array { throw new \BadMethodCallException(sprintf('Method "%s" is not applicable.', __METHOD__)); } public function setBuilder(BaseNodeBuilder $builder): void { $this->builder = $builder; } /** * @return NodeParentInterface|BaseNodeBuilder|NodeDefinition|ArrayNodeDefinition|VariableNodeDefinition|NodeBuilder|self|null */ public function end() { return $this->parent; } protected function instantiateNode(): ClassMappingNode { return new ClassMappingNode($this->name, $this->parent, $this->pathSeparator ?? '.'); } protected function createNode(): NodeInterface { /** @var ClassMappingNode $node */ $node = parent::createNode(); $node->setKeyAttribute('class'); $prototype = $this->getPrototype(); $prototype->parent = $node; $prototypedNode = $prototype->getNode(); if (!$prototypedNode instanceof PrototypeNodeInterface) { throw new \LogicException(sprintf('Prototyped node must be an instance of "%s", got "%s".', PrototypeNodeInterface::class, get_class($prototypedNode))); } $node->setPrototype($prototypedNode); return $node; } private function getPrototype(): NodeDefinition { if (null === $this->prototype) { $this->prototype = ($this->builder ?? new NodeBuilder())->node(null, $this->type); $this->prototype->setParent($this); } return $this->prototype; } } msgphp-0.4.3/src/Domain/Infra/Config/NodeBuilder.php000066400000000000000000000012521327361626700222000ustar00rootroot00000000000000 */ final class NodeBuilder extends BaseNodeBuilder { public function __construct() { parent::__construct(); $this->setNodeClass(ClassMappingNodeDefinition::NAME, ClassMappingNodeDefinition::class); } public function classMappingNode(string $name): ClassMappingNodeDefinition { /** @var ClassMappingNodeDefinition $node */ $node = $this->node($name, ClassMappingNodeDefinition::NAME); return $node; } } msgphp-0.4.3/src/Domain/Infra/Config/TreeBuilder.php000066400000000000000000000012401327361626700222070ustar00rootroot00000000000000 */ final class TreeBuilder extends BaseTreeBuilder { public function rootArray(string $name, BaseNodeBuilder $builder = null): ArrayNodeDefinition { /** @var ArrayNodeDefinition $node */ $node = $this->root($name, 'array', $builder ?? new NodeBuilder()); return $node; } } msgphp-0.4.3/src/Domain/Infra/Console/000077500000000000000000000000001327361626700174705ustar00rootroot00000000000000msgphp-0.4.3/src/Domain/Infra/Console/Command/000077500000000000000000000000001327361626700210465ustar00rootroot00000000000000msgphp-0.4.3/src/Domain/Infra/Console/Command/InitializeDomainProjectionTypesCommand.php000066400000000000000000000027061327361626700313760ustar00rootroot00000000000000 */ final class InitializeDomainProjectionTypesCommand extends Command { protected static $defaultName = 'projection:initialize-types'; private $typeRegistry; public function __construct(DomainProjectionTypeRegistryInterface $typeRegistry) { $this->typeRegistry = $typeRegistry; parent::__construct(); } protected function configure(): void { $this ->setDescription('Initializes all projection types') ->addOption('force', null, InputOption::VALUE_NONE, 'Force initialization by destroying types first'); } protected function execute(InputInterface $input, OutputInterface $output): int { $io = new SymfonyStyle($input, $output); if ($input->getOption('force')) { $this->typeRegistry->destroy(); } $this->typeRegistry->initialize(); $io->success('Projection types successfully initialized'); $io->listing($this->typeRegistry->all()); return 0; } } msgphp-0.4.3/src/Domain/Infra/Console/Command/SynchronizeDomainProjectionsCommand.php000066400000000000000000000035701327361626700307460ustar00rootroot00000000000000 */ final class SynchronizeDomainProjectionsCommand extends Command { protected static $defaultName = 'projection:synchronize'; private $synchronization; private $logger; public function __construct(DomainProjectionSynchronization $synchronization, LoggerInterface $logger = null) { $this->synchronization = $synchronization; $this->logger = $logger; parent::__construct(); } protected function configure(): void { $this ->setDescription('Synchronizes all projections'); } protected function execute(InputInterface $input, OutputInterface $output): int { $io = new SymfonyStyle($input, $output); $succeed = $failed = 0; foreach ($this->synchronization->synchronize() as $document) { if (DomainProjectionDocument::STATUS_SYNCHRONIZED === $document->status) { ++$succeed; } else { ++$failed; } if (null !== $document->error && null !== $this->logger) { $this->logger->error($document->error->getMessage(), ['exception' => $document->error]); } } $io->success($succeed.' projection '.(1 === $succeed ? 'document' : 'documents').' synchronized'); if ($failed) { $io->error($failed.' projection '.(1 === $failed ? 'document' : 'documents').' failed'); } return 0; } } msgphp-0.4.3/src/Domain/Infra/Console/Context/000077500000000000000000000000001327361626700211145ustar00rootroot00000000000000msgphp-0.4.3/src/Domain/Infra/Console/Context/ClassContextElementFactory.php000066400000000000000000000007451327361626700271070ustar00rootroot00000000000000 */ final class ClassContextElementFactory implements ClassContextElementFactoryInterface { public function getElement(string $class, string $method, string $argument): ContextElement { return new ContextElement(ucfirst(preg_replace(['/([A-Z]+)([A-Z][a-z])/', '/([a-z\d])([A-Z])/'], ['\\1 \\2', '\\1 \\2'], $argument))); } } msgphp-0.4.3/src/Domain/Infra/Console/Context/ClassContextElementFactoryInterface.php000066400000000000000000000004431327361626700307230ustar00rootroot00000000000000 */ interface ClassContextElementFactoryInterface { public function getElement(string $class, string $method, string $argument): ContextElement; } msgphp-0.4.3/src/Domain/Infra/Console/Context/ClassContextFactory.php000066400000000000000000000200411327361626700255640ustar00rootroot00000000000000 */ final class ClassContextFactory implements ContextFactoryInterface { public const ALWAYS_OPTIONAL = 1; public const NO_DEFAULTS = 2; public const REUSE_DEFINITION = 4; private $class; private $method; private $classMapping; private $flags = 0; private $elementFactory; private $resolved; private $fieldMapping = []; private $generatedValues = []; public static function getUniqueFieldName(InputDefinition $definition, string $field, bool $isOption = true): string { $known = $isOption ? $definition->getOptions() : $definition->getArguments(); $base = $field; $i = 1; while (isset($known[$field])) { $field = $base.++$i; } return $field; } public function __construct(string $class, string $method, array $classMapping = [], int $flags = 0, ClassContextElementFactoryInterface $elementFactory = null) { $this->class = $class; $this->method = $method; $this->classMapping = $classMapping; $this->flags = $flags; $this->elementFactory = $elementFactory ?? new ClassContextElementFactory(); } public function configure(InputDefinition $definition): void { $this->fieldMapping = []; if ($this->flags & self::REUSE_DEFINITION) { $origOptions = $definition->getOptions(); $origArgs = $definition->getArguments(); } else { $origOptions = $origArgs = []; } foreach ($this->resolve() as $argument) { $isOption = true; if ('bool' === $argument['type']) { $mode = InputOption::VALUE_NONE; } elseif (self::isComplex($argument['type'])) { $mode = InputOption::VALUE_OPTIONAL | InputOption::VALUE_IS_ARRAY; } elseif (!$argument['required'] || ($this->flags & self::ALWAYS_OPTIONAL)) { $mode = InputOption::VALUE_OPTIONAL; } else { $mode = InputArgument::OPTIONAL; $isOption = false; } $field = $isOption ? str_replace('_', '-', $argument['key']) : $argument['key']; if (!isset($origOptions[$field]) && !isset($origArgs[$field])) { $field = self::getUniqueFieldName($definition, $field, $isOption); if ($isOption) { $definition->addOption(new InputOption($field, null, $mode, $argument['element']->description)); } else { $definition->addArgument(new InputArgument($field, $mode, $argument['element']->description)); } } else { $isOption = isset($origOptions[$field]); } $this->fieldMapping[$argument['name']] = [$field, $isOption]; } } public function getContext(InputInterface $input, StyleInterface $io, array $values = [], iterable $resolved = null): array { $context = $normalizers = []; $interactive = $input->isInteractive(); foreach ($resolved ?? $this->resolve() as $argument) { $key = $argument['name']; if (null === $resolved) { [$field, $isOption] = $this->fieldMapping[$key]; $value = $isOption ? $input->getOption($field) : $input->getArgument($field); } else { $field = $key; $value = $argument['value'] ?? null; } if (array_key_exists($key, $values)) { $context[$key] = $values[$key]; continue; } $isEmpty = null === $value || false === $value || [] === $value; $given = !$isEmpty || $input->hasParameterOption('--'.$field); /** @var ContextElement $element */ $element = $argument['element']; $required = $argument['required'] && !($this->flags & self::ALWAYS_OPTIONAL); if (is_array($value) && self::isObject($type = $argument['type']) && ($required || $given)) { $method = is_subclass_of($type, DomainCollectionInterface::class) || is_subclass_of($type, DomainIdInterface::class) ? 'fromValue' : '__construct'; $context[$key] = $this->getContext($input, $io, [], array_map(function (array $argument, int $i) use ($type, $method, $value, $element): array { if (array_key_exists($argument['name'], $value)) { $argument['value'] = $value[$argument['name']]; } elseif (array_key_exists($i, $value)) { $argument['value'] = $value[$i]; } elseif ('bool' === $argument['type']) { $argument['value'] = false; } elseif (self::isComplex($argument['type'])) { $argument['value'] = []; } $child = $this->elementFactory->getElement($type, $method, $argument['name']); $child->label = $element->label.' > '.$child->label; return ['element' => $child] + $argument; }, $objectResolved = ClassMethodResolver::resolve($type, $method), array_keys($objectResolved))); continue; } if (!$isEmpty) { $context[$key] = $element->normalize($value); continue; } if ($required || $given) { if (!$interactive) { throw new \LogicException(sprintf('No value provided for "%s".', $field)); } if ($element->generate($io, $generated)) { $this->generatedValues[] = [$element->label, json_encode($generated)]; $context[$key] = $element->normalize($generated); } else { $context[$key] = $this->askRequiredValue($io, $element, $value); } continue; } if ($this->flags & self::NO_DEFAULTS) { continue; } $context[$key] = $element->normalize($argument['default']); } if ($this->generatedValues) { $io->note('Generated values'); $io->table([], $this->generatedValues); $this->generatedValues = []; } return $context; } private static function isComplex(?string $type): bool { return 'array' === $type || 'iterable' === $type || self::isObject($type); } private static function isObject(?string $type): bool { return null !== $type && (class_exists($type) || interface_exists($type)); } private function resolve(): iterable { if (null !== $this->resolved) { return $this->resolved; } $this->resolved = []; foreach (ClassMethodResolver::resolve($this->class, $this->method) as $argument) { $this->resolved[] = [ 'element' => $this->elementFactory->getElement($this->class, $this->method, $argument['name']), 'type' => isset($argument['type']) ? ($this->classMapping[$argument['type']] ?? $argument['type']) : null, ] + $argument; } return $this->resolved; } private function askRequiredValue(StyleInterface $io, ContextElement $element, $emptyValue) { if (null === $emptyValue) { return $element->askString($io); } if (false === $emptyValue) { return $element->askBool($io); } if ([] === $emptyValue) { return $element->askIterable($io); } return $emptyValue; } } msgphp-0.4.3/src/Domain/Infra/Console/Context/ContextElement.php000066400000000000000000000041401327361626700245620ustar00rootroot00000000000000 */ final class ContextElement { public $label; public $description; private $hide = false; private $generator; private $normalizer; public function __construct(string $label, string $description = '') { $this->label = $label; $this->description = $description; } public function hide(bool $flag = true): self { $this->hide = $flag; return $this; } public function generator(callable $generator): self { $this->generator = $generator; return $this; } public function normalizer(callable $normalizer): self { $this->normalizer = $normalizer; return $this; } public function normalize($value) { return null === $this->normalizer ? $value : ($this->normalizer)($value); } public function generate(StyleInterface $io, &$generated): bool { $generated = null; $result = false; if (null !== $this->generator && $result = $io->confirm(sprintf('Generate a value for "%s"?', $this->label))) { $generated = ($this->generator)(); } unset($generated); return $result; } public function askString(StyleInterface $io): string { do { $value = $this->hide ? $io->askHidden($this->label) : $io->ask($this->label); } while (null === $value); return $this->normalize($value); } public function askBool(StyleInterface $io): bool { return $this->normalize($io->confirm($this->label, false)); } public function askIterable(StyleInterface $io): bool { $i = 0; $value = []; do { $label = $this->label.' ['.$i.']'; $value[] = $this->hide ? $io->askHidden($label) : $io->ask($label); ++$i; } while ($io->confirm('Add another value?', false)); return $this->normalize($value); } } msgphp-0.4.3/src/Domain/Infra/Console/Context/ContextFactoryInterface.php000066400000000000000000000007751327361626700264330ustar00rootroot00000000000000 */ interface ContextFactoryInterface { public function configure(InputDefinition $definition): void; public function getContext(InputInterface $input, StyleInterface $io, array $values = []): array; } msgphp-0.4.3/src/Domain/Infra/Console/Context/DoctrineEntityContextFactory.php000066400000000000000000000057261327361626700275000ustar00rootroot00000000000000 */ final class DoctrineEntityContextFactory implements ContextFactoryInterface { private $factory; private $em; private $class; private $discriminatorField; public function __construct(ContextFactoryInterface $factory, EntityManagerInterface $em, string $class) { $this->factory = $factory; $this->em = $em; $this->class = $class; } public function configure(InputDefinition $definition): void { $this->discriminatorField = null; $metadata = $this->getMetadata(); if (isset($metadata->discriminatorColumn['fieldName'])) { $definition->addOption(new InputOption( $this->discriminatorField = ClassContextFactory::getUniqueFieldName($definition, $metadata->discriminatorColumn['fieldName']), null, InputOption::VALUE_OPTIONAL, 'The entity discriminator value' )); } $this->factory->configure($definition); } public function getContext(InputInterface $input, StyleInterface $io, array $values = []): array { $context = []; if (null !== $this->discriminatorField) { $metadata = $this->getMetadata(); $key = $metadata->discriminatorColumn['fieldName']; if (isset($values[$key])) { $context[$key] = $values[$key]; unset($values[$key]); } elseif (null === $value = $input->getOption($this->discriminatorField)) { $context[$key] = $io->choice('Select discriminator', array_keys($metadata->discriminatorMap), $metadata->discriminatorValue); } elseif (isset($metadata->discriminatorMap[$value])) { $context[$key] = $value; } elseif (false !== $found = array_search($value, $metadata->discriminatorMap, true)) { $context[$key] = $found; } else { throw new \LogicException(sprintf('Invalid entity discriminator "%s" provided.', $value)); } // @todo add feature to ask additional context values, required by the provided discriminator class } return $context + $this->factory->getContext($input, $io, $values); } private function getMetadata(): ClassMetadata { if (!class_exists($this->class) || $this->em->getMetadataFactory()->isTransient($this->class)) { throw InvalidClassException::create($this->class); } return $this->em->getClassMetadata($this->class); } } msgphp-0.4.3/src/Domain/Infra/Console/MessageReceiver.php000066400000000000000000000014511327361626700232530ustar00rootroot00000000000000 */ final class MessageReceiver { /** @var MessageReceivingInterface|null */ private $receiver; public function receive($message): void { if (null === $this->receiver) { return; } $this->receiver->onMessageReceived($message); } public function onCommand(ConsoleCommandEvent $event): void { $this->receiver = ($command = $event->getCommand()) instanceof MessageReceivingInterface ? $command : null; } public function onTerminate(): void { $this->receiver = null; } } msgphp-0.4.3/src/Domain/Infra/DependencyInjection/000077500000000000000000000000001327361626700220075ustar00rootroot00000000000000msgphp-0.4.3/src/Domain/Infra/DependencyInjection/BundleHelper.php000066400000000000000000000117011327361626700250710ustar00rootroot00000000000000 * * @internal */ final class BundleHelper { private static $initialized = []; public static function initDomain(ContainerBuilder $container): void { if ($initialized = &self::getInitialized($container, __FUNCTION__)) { return; } $container->addCompilerPass(new Compiler\ResolveDomainPass(), PassConfig::TYPE_BEFORE_OPTIMIZATION, 100); self::initConsole($container); self::initDoctrineOrm($container); $initialized = true; } public static function boot(ContainerInterface $container): void { if ($initialized = &self::getInitialized($container, __FUNCTION__)) { return; } if ($container->hasParameter($param = 'msgphp.doctrine.type_config')) { foreach ($container->getParameter($param) as $config) { $config['type_class']::setClass($config['class']); $config['type_class']::setDataType($config['type']); } } $initialized = true; } private static function initConsole(ContainerBuilder $container): void { if (!class_exists(ConsoleEvents::class)) { return; } $container->register(ConsoleInfra\Context\ClassContextFactory::class) ->setPublic(false) ->setAbstract(true) ->setAutowired(true) ->setArgument('$method', '__construct') ->setArgument('$classMapping', '%msgphp.domain.class_mapping%'); $container->register(ConsoleInfra\Context\ClassContextElementFactory::class) ->setPublic(false); $container->setAlias(ConsoleInfra\Context\ClassContextElementFactoryInterface::class, new Alias(ConsoleInfra\Context\ClassContextElementFactory::class, false)); $container->register(ConsoleInfra\MessageReceiver::class) ->setPublic(false) ->addTag('kernel.event_listener', ['event' => ConsoleEvents::COMMAND, 'method' => 'onCommand']) ->addTag('kernel.event_listener', ['event' => ConsoleEvents::TERMINATE, 'method' => 'onTerminate']); if (ContainerHelper::hasBundle($container, SimpleBusCommandBusBundle::class)) { $container->register(SimpleBusInfra\Middleware\ConsoleMessageReceiverMiddleware::class) ->setPublic(false) ->setAutowired(true) ->addTag('command_bus_middleware'); } } private static function initDoctrineOrm(ContainerBuilder $container): void { if (!class_exists(DoctrineOrmVersion::class)) { return; } $container->addCompilerPass(new Compiler\DoctrineObjectFieldMappingPass(), PassConfig::TYPE_BEFORE_OPTIMIZATION, 200); $container->register(DoctrineInfra\Event\ObjectFieldMappingListener::class) ->setPublic(false) ->setArgument('$mapping', []) ->addTag('msgphp.domain.process_class_mapping', ['argument' => '$mapping']) ->addTag('doctrine.event_listener', ['event' => DoctrineOrmEvents::loadClassMetadata]); if (ContainerHelper::hasBundle($container, DoctrineBundle::class)) { @mkdir($mappingDir = $container->getParameterBag()->resolveValue('%kernel.cache_dir%/msgphp/doctrine-mapping'), 0777, true); $container->prependExtensionConfig('doctrine', ['orm' => [ 'hydrators' => [ DoctrineInfra\Hydration\ScalarHydrator::NAME => DoctrineInfra\Hydration\ScalarHydrator::class, DoctrineInfra\Hydration\SingleScalarHydrator::NAME => DoctrineInfra\Hydration\SingleScalarHydrator::class, ], 'mappings' => [ 'msgphp' => [ 'dir' => $mappingDir, 'type' => 'xml', 'prefix' => 'MsgPhp', 'is_bundle' => false, ], ], ]]); } } private static function &getInitialized(ContainerInterface $container, string $key) { if (!isset(self::$initialized[$hash = spl_object_hash($container)."\0".$key])) { self::$initialized[$hash] = false; } return self::$initialized[$hash]; } private function __construct() { } } msgphp-0.4.3/src/Domain/Infra/DependencyInjection/Compiler/000077500000000000000000000000001327361626700235615ustar00rootroot00000000000000msgphp-0.4.3/src/Domain/Infra/DependencyInjection/Compiler/DoctrineObjectFieldMappingPass.php000066400000000000000000000045071327361626700323050ustar00rootroot00000000000000 */ final class DoctrineObjectFieldMappingPass implements CompilerPassInterface { use PriorityTaggedServiceTrait; private $tagName; private $listenerId; private $defaultProviders; public function __construct(string $tagName = 'msgphp.doctrine.object_field_mapping', string $listenerId = ObjectFieldMappingListener::class, array $defaultProviders = [EntityFieldsMapping::class]) { $this->tagName = $tagName; $this->listenerId = $listenerId; $this->defaultProviders = $defaultProviders; } public function process(ContainerBuilder $container): void { $mapping = []; $providers = array_merge($this->defaultProviders, array_map(function (Reference $provider) use ($container): string { $provider = (string) $provider; return $container->findDefinition($provider)->getClass() ?? $provider; }, $this->findAndSortTaggedServices($this->tagName, $container))); foreach ($providers as $provider) { if (!ContainerHelper::getClassReflection($container, $provider)->implementsInterface(ObjectFieldMappingProviderInterface::class)) { throw new InvalidArgumentException(sprintf('Provider "%s" must implement "%s".', $provider, ObjectFieldMappingProviderInterface::class)); } $mapping = array_replace_recursive($mapping, $provider::getObjectFieldMapping()); } if ($mapping) { $container->getDefinition($this->listenerId) ->setArgument('$mapping', $mapping); } else { $container->removeDefinition($this->listenerId); } } } msgphp-0.4.3/src/Domain/Infra/DependencyInjection/Compiler/ResolveDomainPass.php000066400000000000000000000176601327361626700277020ustar00rootroot00000000000000 * * @internal */ final class ResolveDomainPass implements CompilerPassInterface { public function process(ContainerBuilder $container): void { $container->setParameter('msgphp.domain.class_mapping', $classMapping = array_merge(...$container->getParameter('msgphp.domain.class_mapping'))); $idClassMapping = array_merge(...$container->getParameter('msgphp.domain.id_class_mapping')); $identityMapping = array_merge(...$container->getParameter('msgphp.domain.identity_mapping')); $this->registerIdentityMapping($container, $identityMapping); $this->registerObjectFactory($container); $this->registerEntityAwareFactory($container, $idClassMapping); $this->registerMessageBus($container); if (interface_exists(CacheWarmerInterface::class) && $container->hasParameter('msgphp.doctrine.mapping_files')) { self::register($container, DoctrineInfra\MappingCacheWarmer::class) ->setArgument('$dirName', 'msgphp/doctrine-mapping') ->setArgument('$mappingFiles', array_merge(...$container->getParameter('msgphp.doctrine.mapping_files'))) ->addTag('kernel.cache_warmer', ['priority' => 100]); } foreach ($container->findTaggedServiceIds('msgphp.domain.process_class_mapping') as $id => $attr) { $definition = $container->getDefinition($id); foreach ($attr as $attr) { if (!isset($attr['argument'])) { continue; } $value = $definition->getArgument($attr['argument']); $definition->setArgument($attr['argument'], self::processClassMapping($value, $classMapping, !empty($attr['array_keys']))); } $definition->clearTag('msgphp.domain.process_class_mapping'); } $params = $container->getParameterBag(); $params->remove('msgphp.domain.id_class_mapping'); $params->remove('msgphp.domain.identity_mapping'); $params->remove('msgphp.doctrine.mapping_files'); } private static function register(ContainerBuilder $container, string $class, string $id = null): Definition { return $container->register($id ?? $class, $class)->setPublic(false); } private static function alias(ContainerBuilder $container, string $alias, string $id): void { $container->setAlias($alias, new Alias($id, false)); } private static function processClassMapping($value, array $classMapping, bool $arrayKeys = false) { if (is_string($value) && isset($classMapping[$value])) { return $classMapping[$value]; } if (!is_array($value)) { return $value; } $result = []; foreach ($value as $k => $v) { $v = self::processClassMapping($v, $classMapping, $arrayKeys); if ($arrayKeys) { $k = self::processClassMapping($k, $classMapping); } $result[$k] = $v; } return $result; } private function registerIdentityMapping(ContainerBuilder $container, array $identityMapping): void { if (ContainerHelper::hasBundle($container, DoctrineBundle::class)) { self::register($container, $aliasId = DoctrineInfra\DomainIdentityMapping::class) ->setAutowired(true) ->setArgument('$classMapping', '%msgphp.domain.class_mapping%'); } else { self::register($container, $aliasId = InMemoryInfra\DomainIdentityMapping::class) ->setArgument('$mapping', $identityMapping) ->setArgument('$accessor', self::register($container, InMemoryInfra\ObjectFieldAccessor::class) ->setAutowired(true)); } self::alias($container, DomainIdentityMappingInterface::class, $aliasId); self::register($container, DomainIdentityHelper::class) ->setAutowired(true); } private function registerObjectFactory(ContainerBuilder $container): void { if ($container->has($id = Factory\DomainObjectFactoryInterface::class)) { return; } self::register($container, $aliasId = Factory\DomainObjectFactory::class) ->addMethodCall('setNestedFactory', [new Reference(Factory\DomainObjectFactoryInterface::class)]); self::register($container, Factory\ClassMappingObjectFactory::class) ->setDecoratedService($aliasId) ->setArgument('$factory', new Reference(Factory\ClassMappingObjectFactory::class.'.inner')) ->setArgument('$mapping', '%msgphp.domain.class_mapping%'); self::alias($container, $id, $aliasId); } private function registerEntityAwareFactory(ContainerBuilder $container, array $idClassMapping): void { if ($container->has($id = Factory\EntityAwareFactoryInterface::class)) { return; } self::register($container, $aliasId = Factory\EntityAwareFactory::class) ->setAutowired(true) ->setArgument('$identifierMapping', $idClassMapping); if (ContainerHelper::hasBundle($container, DoctrineBundle::class)) { self::register($container, DoctrineInfra\EntityAwareFactory::class) ->setAutowired(true) ->setDecoratedService($aliasId) ->setArgument('$factory', new Reference(DoctrineInfra\EntityAwareFactory::class.'.inner')) ->setArgument('$classMapping', '%msgphp.domain.class_mapping%'); } self::alias($container, $id, $aliasId); } private function registerMessageBus(ContainerBuilder $container): void { if ($container->has($id = Message\DomainMessageBusInterface::class)) { return; } $aliasId = null; if (ContainerHelper::hasBundle($container, SimpleBusCommandBusBundle::class)) { self::register($container, $aliasId = SimpleBusInfra\DomainMessageBus::class) ->setArgument('$bus', new Reference('simple_bus.command_bus')); } if ($container->has(MessageBusInterface::class)) { self::register($container, $aliasId = MessengerInfra\DomainMessageBus::class) ->setAutowired(true); if (class_exists(ConsoleEvents::class)) { foreach ($container->findTaggedServiceIds('messenger.bus') as $id => $attr) { self::register($container, MessengerInfra\ConsoleMessageReceiverBus::class, MessengerInfra\ConsoleMessageReceiverBus::class.'.'.$id) ->setDecoratedService($id) ->setArgument('$bus', MessengerInfra\ConsoleMessageReceiverBus::class.'.'.$id.'.inner'); } } } if (null === $aliasId) { foreach ($container->findTaggedServiceIds('msgphp.domain.message_aware') as $id => $attr) { $container->removeDefinition($id); } return; } self::alias($container, $id, $aliasId); } } msgphp-0.4.3/src/Domain/Infra/DependencyInjection/ConfigHelper.php000066400000000000000000000072031327361626700250670ustar00rootroot00000000000000 * * @internal */ final class ConfigHelper { public const DEFAULT_ID_TYPE = 'integer'; public const UUID_TYPES = ['uuid', 'uuid_binary', 'uuid_binary_ordered_time']; public static function defaultBundleConfig(array $defaultIdClassMapping, array $idClassMappingPerType): \Closure { return function (array $value) use ($defaultIdClassMapping, $idClassMappingPerType): array { $defaultType = $value['default_id_type'] ?? ConfigHelper::DEFAULT_ID_TYPE; unset($value['default_id_type']); if (isset($value['id_type_mapping'])) { foreach ($value['id_type_mapping'] as $class => $type) { if (isset($value['class_mapping'][$class])) { continue; } if (null === $mappedClass = $idClassMapping[$type][$class] ?? $defaultIdClassMapping[$class] ?? null) { $mappedClass = in_array($type, self::UUID_TYPES, true) ? UuidInfra\DomainId::class : DomainId::class; } $value['class_mapping'][$class] = $mappedClass; } } if (isset($idClassMappingPerType[$defaultType])) { $value['class_mapping'] += $idClassMappingPerType[$defaultType]; $value['id_type_mapping'] += array_fill_keys(array_keys($idClassMappingPerType[$defaultType]), $defaultType); } $value['class_mapping'] += $defaultIdClassMapping; $value['id_type_mapping'] += array_fill_keys(array_keys($defaultIdClassMapping), $defaultType); return $value; }; } public static function resolveCommandMappingConfig(array $commandMapping, array $classMapping, array &$config): void { foreach ($commandMapping as $commandClass => $features) { $mappedClass = $classMapping[$commandClass] ?? $commandClass; $isEventHandler = self::exists($mappedClass) && is_subclass_of($mappedClass, DomainEventHandlerInterface::class); foreach ($features as $feature => $featureInfo) { if (!trait_exists($feature)) { $config[$feature] = $featureInfo; } elseif (self::uses($mappedClass, $feature)) { $config += array_fill_keys($featureInfo, $isEventHandler); } } } } private static function exists(string $class): bool { spl_autoload_register($loader = function (): void { throw new \LogicException(); }); try { return class_exists($class) || interface_exists($class, false); } catch (\LogicException $e) { return false; } finally { spl_autoload_unregister($loader); } } private static function uses(string $class, string $trait): bool { static $uses = []; if (!isset($uses[$class])) { $resolve = function (string $class) use (&$resolve): array { $resolved = []; foreach (class_uses($class) as $used) { $resolved[$used] = true; $resolved += $resolve($used); } return $resolved; }; $uses[$class] = $resolve($class); } return isset($uses[$class][$trait]); } private function __construct() { } } msgphp-0.4.3/src/Domain/Infra/DependencyInjection/ContainerHelper.php000066400000000000000000000277011327361626700256110ustar00rootroot00000000000000 * * @internal */ final class ContainerHelper { private static $counter = 0; public static function hasBundle(Container $container, string $class): bool { return in_array($class, $container->getParameter('kernel.bundles'), true); } public static function getBundles(Container $container): array { return array_flip($container->getParameter('kernel.bundles')); } public static function getClassReflection(ContainerBuilder $container, ?string $class): \ReflectionClass { if (!$class || !($reflection = $container->getReflectionClass($class))) { throw new InvalidArgumentException(sprintf('Invalid class "%s".', $class)); } return $reflection; } public static function removeId(ContainerBuilder $container, string $id): void { $container->removeDefinition($id); $container->removeAlias($id); foreach ($container->getAliases() as $aliasId => $alias) { if ($id === (string) $alias) { $container->removeAlias($aliasId); } } } public static function removeIf(ContainerBuilder $container, bool $condition, array $ids): void { if (!$condition) { return; } foreach ($ids as $id) { self::removeId($container, $id); } } public static function registerAnonymous(ContainerBuilder $container, string $class, bool $child = false): Definition { $definition = $child ? new ChildDefinition($class) : new Definition($class); $definition->setPublic(false); return $container->setDefinition($class.'.'.ContainerBuilder::hash(__METHOD__.++self::$counter), $definition); } public static function registerConsoleClassContextFactory(ContainerBuilder $container, string $class, int $flags = 0): Definition { $definition = self::registerAnonymous($container, ConsoleInfra\Context\ClassContextFactory::class, true) ->setArgument('$class', $class) ->setArgument('$flags', $flags); if (class_exists(DoctrineOrmVersion::class) && self::hasBundle($container, DoctrineBundle::class)) { $definition = self::registerAnonymous($container, ConsoleInfra\Context\DoctrineEntityContextFactory::class) ->setAutowired(true) ->setArgument('$factory', $definition) ->setArgument('$class', $class); } return $definition; } public static function configureIdentityMapping(ContainerBuilder $container, array $classMapping, array $identityMapping): void { foreach ($identityMapping as $class => $mapping) { if (isset($classMapping[$class]) && !isset($identityMapping[$classMapping[$class]])) { $identityMapping[$classMapping[$class]] = $mapping; } } $values = $container->hasParameter($param = 'msgphp.domain.identity_mapping') ? $container->getParameter($param) : []; $values[] = $identityMapping; $container->setParameter($param, $values); } public static function configureEntityFactory(ContainerBuilder $container, array $classMapping, array $idClassMapping): void { foreach ($idClassMapping as $class => $idClass) { if (isset($classMapping[$class]) && !isset($idClassMapping[$classMapping[$class]])) { $idClassMapping[$classMapping[$class]] = $idClass; } } $values = $container->hasParameter($param = 'msgphp.domain.class_mapping') ? $container->getParameter($param) : []; $values[] = $classMapping; $container->setParameter($param, $values); $values = $container->hasParameter($param = 'msgphp.domain.id_class_mapping') ? $container->getParameter($param) : []; $values[] = $idClassMapping; $container->setParameter($param, $values); } public static function configureDoctrineDbalTypes(ContainerBuilder $container, array $classMapping, array $idTypeMapping, array $typeClassMapping): void { if (!class_exists(DoctrineType::class)) { return; } $dbalTypes = $mappingTypes = $typeConfig = []; $uuidMapping = [ 'uuid' => DoctrineUuid\UuidType::class, 'uuid_binary' => DoctrineUuid\UuidBinaryType::class, 'uuid_binary_ordered_time' => DoctrineUuid\UuidBinaryOrderedTimeType::class, ]; foreach ($typeClassMapping as $idClass => $typeClass) { $type = $idTypeMapping[$idClass] ?? DoctrineType::INTEGER; if (isset($uuidMapping[$type])) { if (!class_exists($uuidClass = $uuidMapping[$type])) { throw new \LogicException(sprintf('Type "%s" for identifier "%s" requires "ramsey/uuid-doctrine".', $type, $idClass)); } $dbalTypes[$uuidClass::NAME] = $uuidClass; if ('uuid_binary' === $type || 'uuid_binary_ordered_time' === $type) { $mappingTypes[$type] = 'binary'; } } if (!defined($typeClass.'::NAME')) { throw new \LogicException(sprintf('Type class "%s" for identifier "%s" requires a "NAME" constant.', $typeClass, $idClass)); } $dbalTypes[$typeClass::NAME] = $typeClass; $typeConfig[$typeClass::NAME] = ['class' => $classMapping[$idClass] ?? $idClass, 'type' => $type, 'type_class' => $typeClass]; } if ($dbalTypes || $mappingTypes) { if ($container->hasParameter($param = 'msgphp.doctrine.type_config')) { $typeConfig += $container->getParameter($param); } $container->setParameter($param, $typeConfig); if (self::hasBundle($container, DoctrineBundle::class)) { $container->prependExtensionConfig('doctrine', ['dbal' => [ 'types' => $dbalTypes, 'mapping_types' => $mappingTypes, ]]); } } } public static function configureDoctrineOrmMapping(ContainerBuilder $container, array $mappingFiles, array $objectFieldMappings = []): void { $values = $container->hasParameter($param = 'msgphp.doctrine.mapping_files') ? $container->getParameter($param) : []; $values[] = $mappingFiles; $container->setParameter($param, $values); foreach ($objectFieldMappings as $class) { $container->register($class) ->setPublic(false) ->addTag('msgphp.doctrine.object_field_mapping', ['priority' => -100]); } } public static function configureDoctrineOrmTargetEntities(ContainerBuilder $container, array $classMapping): void { if (!class_exists(DoctrineOrmVersion::class) || !self::hasBundle($container, DoctrineBundle::class)) { return; } $container->prependExtensionConfig('doctrine', [ 'orm' => [ 'resolve_target_entities' => $classMapping, ], ]); } public static function configureDoctrineOrmRepositories(ContainerBuilder $container, array $classMapping, array $repositoryEntityMapping): void { foreach ($repositoryEntityMapping as $repository => $entity) { if (!isset($classMapping[$entity])) { $container->removeDefinition($repository); continue; } ($definition = $container->getDefinition($repository)) ->setArgument('$class', $classMapping[$entity]); foreach (self::getClassReflection($container, $definition->getClass() ?? $repository)->getInterfaceNames() as $interface) { if (!$container->has($interface)) { $container->setAlias($interface, new Alias($repository, false)); } } } } public static function configureCommandMessages(ContainerBuilder $container, array $classMapping, array $commands): void { $messengerEnabled = interface_exists(MessageBusInterface::class); $simpleBusEnabled = self::hasBundle($container, SimpleBusCommandBusBundle::class); foreach ($container->findTaggedServiceIds('msgphp.domain.command_handler') as $id => $attr) { $definition = $container->getDefinition($id); $command = self::getClassReflection($container, $definition->getClass() ?? $id)->getMethod('__invoke')->getParameters()[0]->getClass()->getName(); if (empty($commands[$command])) { $container->removeDefinition($id); continue; } $mappedCommand = $classMapping[$command] ?? null; if ($messengerEnabled) { $definition->addTag('messenger.message_handler', ['handles' => $command]); if (null !== $mappedCommand) { $definition->addTag('messenger.message_handler', ['handles' => $mappedCommand]); } } if ($simpleBusEnabled) { $definition ->setPublic(true) ->addTag('command_handler', ['handles' => $command]); if (null !== $mappedCommand) { $definition->addTag('command_handler', ['handles' => $mappedCommand]); } } $definition->addTag('msgphp.domain.message_aware'); } } public static function configureEventMessages(ContainerBuilder $container, array $classMapping, array $events): void { $messengerHandler = $simpleBusHandler = null; if (interface_exists(MessageBusInterface::class)) { $messengerHandler = self::registerAnonymous($container, FallbackMessageHandler::class); } if (self::hasBundle($container, SimpleBusCommandBusBundle::class)) { $simpleBusHandler = self::registerAnonymous($container, FallbackMessageHandler::class); $simpleBusHandler->setPublic(true); if (self::hasBundle($container, SimpleBusEventBusBundle::class)) { $simpleBusHandler->setArgument('$bus', self::registerAnonymous($container, SimpleBusInfra\DomainMessageBus::class) ->setArgument('$bus', new Reference('simple_bus.event_bus'))); } } foreach ($events as $event) { $mappedEvent = $classMapping[$event] ?? null; if (null !== $messengerHandler) { $messengerHandler->addTag('messenger.message_handler', ['handles' => $event]); if (null !== $mappedEvent) { $messengerHandler->addTag('messenger.message_handler', ['handles' => $mappedEvent]); } } if (null !== $simpleBusHandler) { $simpleBusHandler->addTag('command_handler', ['handles' => $event]); if (null !== $mappedEvent) { $simpleBusHandler->addTag('command_handler', ['handles' => $mappedEvent]); } } } } private function __construct() { } } msgphp-0.4.3/src/Domain/Infra/Doctrine/000077500000000000000000000000001327361626700176355ustar00rootroot00000000000000msgphp-0.4.3/src/Domain/Infra/Doctrine/DomainCollection.php000066400000000000000000000040331327361626700235710ustar00rootroot00000000000000 */ final class DomainCollection implements DomainCollectionInterface { private $collection; /** * @return $this|self */ public static function fromValue(?iterable $value): DomainCollectionInterface { if ($value instanceof Collection) { return new self($value); } return new self(new ArrayCollection($value instanceof \Traversable ? iterator_to_array($value) : $value ?? [])); } public function __construct(Collection $collection) { $this->collection = $collection; } public function getIterator(): \Traversable { return new \ArrayIterator($this->collection->toArray()); } public function isEmpty(): bool { return $this->collection->isEmpty(); } public function contains($element): bool { return $this->collection->contains($element); } public function containsKey($key): bool { return $this->collection->containsKey($key); } public function first() { return $this->collection->first(); } public function last() { return $this->collection->last(); } public function get($key) { return $this->collection->get($key); } public function filter(callable $filter): DomainCollectionInterface { return new self($this->collection->filter($filter)); } public function slice(int $offset, int $limit = 0): DomainCollectionInterface { return new self(new ArrayCollection($this->collection->slice($offset, $limit ?: null))); } public function map(callable $mapper): array { return $this->collection->map($mapper)->toArray(); } public function count(): int { return $this->collection->count(); } } msgphp-0.4.3/src/Domain/Infra/Doctrine/DomainEntityRepositoryTrait.php000066400000000000000000000150351327361626700260620ustar00rootroot00000000000000 */ trait DomainEntityRepositoryTrait { private $class; private $em; private $identityHelper; public function __construct(string $class, EntityManagerInterface $em, DomainIdentityHelper $identityHelper = null) { $this->class = $class; $this->em = $em; $this->identityHelper = $identityHelper ?? new DomainIdentityHelper(new DomainIdentityMapping($em)); } private function doFindAll(int $offset = 0, int $limit = 0): DomainCollectionInterface { return $this->createResultSet($this->createQueryBuilder()->getQuery(), $offset, $limit); } private function doFindAllByFields(array $fields, int $offset = 0, int $limit = 0): DomainCollectionInterface { if (!$fields) { throw new \LogicException('No fields provided.'); } $this->addFieldCriteria($qb = $this->createQueryBuilder(), $fields); return $this->createResultSet($qb->getQuery(), $offset, $limit); } /** * @return object */ private function doFind($id) { if (!$this->identityHelper->isIdentity($this->class, $id)) { throw EntityNotFoundException::createForId($this->class, $id); } return $this->doFindByFields($this->identityHelper->toIdentity($this->class, $id)); } /** * @return object */ private function doFindByFields(array $fields) { if (!$fields) { throw new \LogicException('No fields provided.'); } $this->addFieldCriteria($qb = $this->createQueryBuilder(), $fields); $qb->setFirstResult(0); $qb->setMaxResults(1); if (null === $entity = $qb->getQuery()->getOneOrNullResult()) { if ($this->identityHelper->isIdentity($this->class, $fields)) { throw EntityNotFoundException::createForId($this->class, $fields); } throw EntityNotFoundException::createForFields($this->class, $fields); } return $entity; } private function doExists($id): bool { if (!$this->identityHelper->isIdentity($this->class, $id)) { return false; } return $this->doExistsByFields($this->identityHelper->toIdentity($this->class, $id)); } private function doExistsByFields(array $fields): bool { if (!$fields) { throw new \LogicException('No fields provided.'); } $this->addFieldCriteria($qb = $this->createQueryBuilder(), $fields); $qb->select('1'); $qb->setFirstResult(0); $qb->setMaxResults(1); return (bool) $qb->getQuery()->getScalarResult(); } /** * @param object $entity */ private function doSave($entity): void { if (!$entity instanceof $this->class) { throw InvalidClassException::create(get_class($entity)); } $this->em->persist($entity); try { $this->em->flush(); } catch (UniqueConstraintViolationException $e) { throw DuplicateEntityException::createForId(get_class($entity), $this->identityHelper->getIdentity($entity)); } } /** * @param object $entity */ private function doDelete($entity): void { if (!$entity instanceof $this->class) { throw InvalidClassException::create(get_class($entity)); } $this->em->remove($entity); $this->em->flush(); } private function createResultSet(Query $query, int $offset = null, int $limit = null, $hydrate = Query::HYDRATE_OBJECT): DomainCollectionInterface { if (null !== $offset || !$query->getFirstResult()) { $query->setFirstResult($offset ?? 0); } if (null !== $limit) { $query->setMaxResults(0 === $limit ? null : $limit); } return DomainCollectionFactory::create($query->getResult($hydrate)); } private function createQueryBuilder(string $alias = null): QueryBuilder { if (null === $alias) { $alias = $this->alias; } $qb = $this->em->createQueryBuilder(); $qb->select($alias); $qb->from($this->class, $alias); return $qb; } private function addFieldCriteria(QueryBuilder $qb, array $fields, bool $or = false, string $alias = null): void { if (!$fields) { return; } $expr = $qb->expr(); $where = $or ? $expr->orX() : $expr->andX(); $alias = $alias ?? $this->alias; $idFields = array_flip($this->identityHelper->getIdentifierFieldNames($this->class)); $associations = $this->em->getClassMetadata($this->class)->getAssociationMappings(); foreach ($fields as $field => $value) { if (isset($idFields[$field]) && $this->identityHelper->isEmptyIdentifier($value)) { $where->add('TRUE = FALSE'); continue; } $fieldAlias = $alias.'.'.$field; if (null === $value) { $where->add($expr->isNull($fieldAlias)); continue; } if (true === $value || false === $value) { $where->add($expr->eq($fieldAlias, $value ? 'TRUE' : 'FALSE')); continue; } $param = $this->addFieldParameter($qb, $field, $value); if (is_array($value)) { $where->add($expr->in($fieldAlias, $param)); } elseif (isset($associations[$field])) { $where->add($expr->eq('IDENTITY('.$fieldAlias.')', $param)); } else { $where->add($expr->eq($fieldAlias, $param)); } } $qb->andWhere($where); } private function addFieldParameter(QueryBuilder $qb, string $field, $value, string $type = null): string { $name = $base = str_replace('.', '_', $field); $counter = 0; while (null !== $qb->getParameter($name)) { $name = $base.++$counter; } $qb->setParameter($name, $value, $type ?? DomainIdType::resolveName($value)); return ':'.$name; } } msgphp-0.4.3/src/Domain/Infra/Doctrine/DomainIdType.php000066400000000000000000000071711327361626700227020ustar00rootroot00000000000000 */ class DomainIdType extends Type { public const NAME = 'msgphp_domain_id'; private static $mapping = []; final public static function setClass(string $class): void { if (!is_subclass_of($class, DomainIdInterface::class)) { throw new \LogicException(sprintf('Domain ID class must be a sub class of "%s", got "%s".', DomainIdInterface::class, $class)); } self::$mapping[static::class]['class'] = $class; } final public static function getClass(): string { return self::$mapping[static::class]['class'] ?? DomainId::class; } final public static function setDataType(string $type): void { self::$mapping[static::class]['data_type'] = $type; } final public static function getDataType(): string { return self::$mapping[static::class]['data_type'] ?? Type::INTEGER; } /** * @internal */ final public static function resetMapping(): void { self::$mapping = []; } /** * @internal */ final public static function resolveName($value): ?string { if ($value instanceof DomainIdInterface) { $class = get_class($value); foreach (self::$mapping as $type => $mapping) { if ($class === $mapping['class']) { return $type::NAME; } } return self::NAME; } return null; } /** * @internal */ final public static function resolveValue($value, AbstractPlatform $platform) { if ($value instanceof DomainIdInterface) { $class = get_class($value); $type = Type::INTEGER; foreach (self::$mapping as $type => $mapping) { if ($class === $mapping['class']) { $type = $mapping['data_type']; break; } } return self::getType($type)->convertToPHPValue($value->isEmpty() ? null : $value->toString(), $platform); } return $value; } final public function getName(): string { return static::NAME; } final public function getSQLDeclaration(array $fieldDeclaration, AbstractPlatform $platform): string { return static::getInnerType()->getSQLDeclaration($fieldDeclaration, $platform); } final public function convertToDatabaseValue($value, AbstractPlatform $platform) { if ($value instanceof DomainIdInterface) { $value = $value->isEmpty() ? null : $value->toString(); } try { return static::getInnerType()->convertToDatabaseValue($value, $platform); } catch (ConversionException $e) { throw ConversionException::conversionFailed($value, $this->getName()); } } final public function convertToPHPValue($value, AbstractPlatform $platform): ?DomainIdInterface { try { $value = static::getInnerType()->convertToPHPValue($value, $platform); } catch (ConversionException $e) { throw ConversionException::conversionFailed($value, $this->getName()); } return null === $value ? null : static::getClass()::fromValue($value); } final protected static function getInnerType(): Type { return self::getType(static::getDataType()); } } msgphp-0.4.3/src/Domain/Infra/Doctrine/DomainIdentityMapping.php000066400000000000000000000030721327361626700246050ustar00rootroot00000000000000 */ final class DomainIdentityMapping implements DomainIdentityMappingInterface { private $em; private $classMapping; public function __construct(EntityManagerInterface $em, array $classMapping = []) { $this->em = $em; $this->classMapping = $classMapping; } public function getIdentifierFieldNames(string $class): array { return $this->getMetadata($class)->getIdentifierFieldNames(); } public function getIdentity($object): array { return array_filter($this->getMetadata(get_class($object))->getIdentifierValues($object), function ($value) { if ($value instanceof DomainIdInterface) { return !$value->isEmpty(); } if (is_object($value)) { return (bool) $this->getIdentity($value); } return null !== $value; }); } private function getMetadata(string $class): ClassMetadata { $class = $this->classMapping[$class] ?? $class; if (!class_exists($class) || $this->em->getMetadataFactory()->isTransient($class)) { throw InvalidClassException::create($class); } return $this->em->getClassMetadata($class); } } msgphp-0.4.3/src/Domain/Infra/Doctrine/EntityAwareFactory.php000066400000000000000000000054001327361626700241310ustar00rootroot00000000000000 */ final class EntityAwareFactory implements EntityAwareFactoryInterface { private $factory; private $em; private $classMapping; public function __construct(EntityAwareFactoryInterface $factory, EntityManagerInterface $em, array $classMapping = []) { $this->factory = $factory; $this->em = $em; $this->classMapping = $classMapping; } public function create(string $class, array $context = []) { $class = $this->classMapping[$class] ?? $class; if ($this->isManaged($class)) { $class = $this->getDiscriminatorClass($class, $context); } return $this->factory->create($class, $context); } public function reference(string $class, $id) { if (!$this->isManaged($class = $this->classMapping[$class] ?? $class)) { throw InvalidClassException::create($class); } if (is_array($id)) { $class = $this->getDiscriminatorClass($class, $id, true); } if (null === $ref = $this->em->getReference($class, $id)) { throw InvalidClassException::create($class); } return $ref; } public function identify(string $class, $value): DomainIdInterface { if (!$this->isManaged($class = $this->classMapping[$class] ?? $class)) { throw InvalidClassException::create($class); } return $this->factory->identify($class, $value); } public function nextIdentifier(string $class): DomainIdInterface { if (!$this->isManaged($class = $this->classMapping[$class] ?? $class)) { throw InvalidClassException::create($class); } return $this->factory->nextIdentifier($class); } private function isManaged(string $class): bool { return class_exists($class) && !$this->em->getMetadataFactory()->isTransient($class); } private function getDiscriminatorClass(string $class, array &$context, bool $clear = false): string { $metadata = $this->em->getClassMetadata($class); if (isset($metadata->discriminatorColumn['fieldName'], $context[$metadata->discriminatorColumn['fieldName']])) { $class = $metadata->discriminatorMap[$context[$metadata->discriminatorColumn['fieldName']]] ?? $class; if ($clear) { unset($context[$metadata->discriminatorColumn['fieldName']]); } } unset($context); return $class; } } msgphp-0.4.3/src/Domain/Infra/Doctrine/EntityFieldsMapping.php000066400000000000000000000023111327361626700242620ustar00rootroot00000000000000 * * @internal */ final class EntityFieldsMapping implements ObjectFieldMappingProviderInterface { public static function getObjectFieldMapping(): array { return [ Features\CanBeConfirmed::class => [ 'confirmationToken' => [ 'type' => 'string', 'unique' => true, 'nullable' => true, ], 'confirmedAt' => [ 'type' => 'datetime', 'nullable' => true, ], ], Fields\CreatedAtField::class => [ 'createdAt' => [ 'type' => 'datetime', ], ], Fields\EnabledField::class => [ 'enabled' => [ 'type' => 'boolean', ], ], Fields\LastUpdatedAtField::class => [ 'lastUpdatedAt' => [ 'type' => 'datetime', ], ], ]; } } msgphp-0.4.3/src/Domain/Infra/Doctrine/Event/000077500000000000000000000000001327361626700207165ustar00rootroot00000000000000msgphp-0.4.3/src/Domain/Infra/Doctrine/Event/ObjectFieldMappingListener.php000066400000000000000000000106121327361626700266230ustar00rootroot00000000000000 */ final class ObjectFieldMappingListener { private $mapping; /** @var ClassMetadataFactory|null */ private $metadataFactory; public function __construct(array $mapping) { $this->mapping = $mapping; } public function loadClassMetadata(LoadClassMetadataEventArgs $event): void { if (!$this->mapping) { return; } $this->metadataFactory = $event->getEntityManager()->getMetadataFactory(); $this->processClassFields($event->getClassMetadata()); $this->metadataFactory = null; } private function processClassFields(ClassMetadataInfo $metadata, \ReflectionClass $class = null): void { $class = $class ?? $metadata->getReflectionClass(); if (isset($this->mapping[$name = $class->getName()])) { $this->processFieldMapping($metadata, $this->mapping[$name]); } foreach ($class->getTraits() as $trait) { $this->processClassFields($metadata, $trait); } } private function processFieldMapping(ClassMetadataInfo $metadata, array $fields): void { foreach ($fields as $field => $mapping) { if ($metadata->hasField($field) || $metadata->hasAssociation($field)) { continue; } $mapping = ['fieldName' => $field] + $mapping; if (isset($mapping['type']) && method_exists($metadata, $method = 'map'.ucfirst($mapping['type']))) { unset($mapping['type']); $metadata->$method($mapping); if ('mapEmbedded' === $method) { $embeddableMetadata = $this->getMetadata($mapping['class']); if ($embeddableMetadata->isEmbeddedClass) { $this->addNestedEmbeddedClasses($embeddableMetadata, $metadata, $field); } $identifier = $embeddableMetadata->getIdentifier(); if (!empty($identifier)) { $this->inheritIdGeneratorMapping($metadata, $embeddableMetadata); } $metadata->inlineEmbeddable($field, $embeddableMetadata); } } else { $metadata->mapField($mapping); } } } private function addNestedEmbeddedClasses(ClassMetadataInfo $subClass, ClassMetadataInfo $parentClass, string $prefix): void { foreach ($subClass->embeddedClasses as $property => $embeddableClass) { if (isset($embeddableClass['inherited'])) { continue; } $embeddableMetadata = $this->getMetadata($embeddableClass['class']); $parentClass->mapEmbedded([ 'fieldName' => $prefix.'.'.$property, 'class' => $embeddableMetadata->name, 'columnPrefix' => $embeddableClass['columnPrefix'], 'declaredField' => $embeddableClass['declaredField'] ? $prefix.'.'.$embeddableClass['declaredField'] : $prefix, 'originalField' => $embeddableClass['originalField'] ?: $property, ]); } } private function inheritIdGeneratorMapping(ClassMetadataInfo $class, ClassMetadataInfo $parent): void { if ($parent->isIdGeneratorSequence()) { $class->setSequenceGeneratorDefinition($parent->sequenceGeneratorDefinition); } elseif ($parent->isIdGeneratorTable()) { $class->tableGeneratorDefinition = $parent->tableGeneratorDefinition; } if ($parent->generatorType) { $class->setIdGeneratorType($parent->generatorType); } if ($parent->idGenerator) { $class->setIdGenerator($parent->idGenerator); } } private function getMetadata(string $class): ClassMetadataInfo { if (null === $this->metadataFactory) { throw new \LogicException('Metadata factory not set.'); } $loaded = $this->metadataFactory->getLoadedMetadata(); /** @var ClassMetadataInfo $metadata */ $metadata = $loaded[$class] ?? $this->metadataFactory->getMetadataFor($class); return $metadata; } } msgphp-0.4.3/src/Domain/Infra/Doctrine/Hydration/000077500000000000000000000000001327361626700215765ustar00rootroot00000000000000msgphp-0.4.3/src/Domain/Infra/Doctrine/Hydration/ScalarHydrator.php000066400000000000000000000014251327361626700252330ustar00rootroot00000000000000hydrateColumnInfo($key)) && isset($info['type']) && $info['type'] instanceof DomainIdType) { $value = DomainIdType::getType($info['type']::getDataType())->convertToPHPValue($value, $this->_platform); } unset($value); }); return parent::gatherScalarRowData($data); } } msgphp-0.4.3/src/Domain/Infra/Doctrine/Hydration/SingleScalarHydrator.php000066400000000000000000000014641327361626700264000ustar00rootroot00000000000000hydrateColumnInfo($key)) && isset($info['type']) && $info['type'] instanceof DomainIdType) { $value = DomainIdType::getType($info['type']::getDataType())->convertToPHPValue($value, $this->_platform); } unset($value); }); return parent::gatherScalarRowData($data); } } msgphp-0.4.3/src/Domain/Infra/Doctrine/MappingCacheWarmer.php000066400000000000000000000016171327361626700240500ustar00rootroot00000000000000 * * @internal */ final class MappingCacheWarmer implements CacheWarmerInterface { private $dirName; private $mappingFiles; public function __construct(string $dirName, array $mappingFiles) { $this->dirName = $dirName; $this->mappingFiles = $mappingFiles; } public function isOptional(): bool { return false; } public function warmUp($cacheDir): void { $filesystem = new Filesystem(); $filesystem->mkdir($target = $cacheDir.'/'.$this->dirName); foreach ($this->mappingFiles as $file) { $filesystem->copy($file, $target.'/'.basename($file)); } } } msgphp-0.4.3/src/Domain/Infra/Doctrine/ObjectFieldMappingProviderInterface.php000066400000000000000000000007501327361626700273720ustar00rootroot00000000000000 */ interface ObjectFieldMappingProviderInterface { public const TYPE_EMBEDDED = 'embedded'; public const TYPE_MANY_TO_MANY = 'manyToMany'; public const TYPE_MANY_TO_ONE = 'manyToOne'; public const TYPE_ONE_TO_MANY = 'oneToMany'; public const TYPE_ONE_TO_ONE = 'oneToOne'; public static function getObjectFieldMapping(): array; } msgphp-0.4.3/src/Domain/Infra/Elasticsearch/000077500000000000000000000000001327361626700206405ustar00rootroot00000000000000msgphp-0.4.3/src/Domain/Infra/Elasticsearch/DocumentMappingProviderInterface.php000066400000000000000000000003751327361626700300040ustar00rootroot00000000000000 */ interface DocumentMappingProviderInterface { public static function provideDocumentMappings(): iterable; } msgphp-0.4.3/src/Domain/Infra/Elasticsearch/DomainProjectionRepository.php000066400000000000000000000047271327361626700267270ustar00rootroot00000000000000 */ final class DomainProjectionRepository implements DomainProjectionRepositoryInterface { private $client; private $index; public function __construct(Client $client, string $index) { $this->client = $client; $this->index = $index; } /** * @return DomainProjectionInterface[] */ public function findAll(string $type, int $offset = 0, int $limit = 0): iterable { $params = [ 'index' => $this->index, 'type' => $type, 'body' => [ 'from' => $offset, 'query' => ['match_all' => new \stdClass()], ], ]; if ($limit) { $params['body']['size'] = $limit; } $documents = $this->client->search($params); foreach ($documents['hits']['hits'] ?? [] as $document) { yield $document['_type']::fromDocument($document['_source']); } } public function find(string $type, string $id): ?DomainProjectionInterface { try { $document = $this->client->get([ 'index' => $this->index, 'type' => $type, 'id' => $id, ]); return $document['_type']::fromDocument($document['_source']); } catch (Missing404Exception $e) { return null; } } public function clear(string $type): void { $this->client->deleteByQuery([ 'index' => $this->index, 'type' => $type, 'body' => [ 'query' => ['match_all' => new \stdClass()], ], ]); } public function save(DomainProjectionDocument $document): void { $params = ['index' => $this->index, 'type' => $document->getType(), 'body' => $document->getBody()]; if (null !== $id = $document->getId()) { $params['id'] = $id; } $this->client->index($params); } public function delete(string $type, string $id): void { $this->client->delete([ 'index' => $this->index, 'type' => $type, 'id' => $id, ]); } } msgphp-0.4.3/src/Domain/Infra/Elasticsearch/DomainProjectionTypeRegistry.php000066400000000000000000000064201327361626700272120ustar00rootroot00000000000000 */ final class DomainProjectionTypeRegistry implements DomainProjectionTypeRegistryInterface { private const DEFAULT_PROPERTY_TYPE = 'text'; private $client; private $index; private $mappings; private $settings; private $logger; private $types; private $indexParams; public function __construct(Client $client, string $index, array $mappings, array $settings = [], LoggerInterface $logger = null) { $this->client = $client; $this->index = $index; $this->mappings = $mappings; $this->settings = $settings; $this->logger = $logger; } /** * @return string[] */ public function all(): array { return $this->types ?? ($this->types = array_keys($this->getIndexParams()['body']['mappings'] ?? [])); } public function initialize(): void { $indices = $this->client->indices(); if ($indices->exists($params = ['index' => $this->index])) { return; } $indices->create($params + $this->getIndexParams()); if (null !== $this->logger) { $this->logger->info('Initialized Elasticsearch index "{index}".', ['index' => $this->index]); } } public function destroy(): void { $indices = $this->client->indices(); if (!$indices->exists($params = ['index' => $this->index])) { return; } $indices->delete($params); if (null !== $this->logger) { $this->logger->info('Destroyed Elasticsearch index "{index}".', ['index' => $this->index]); } } private function getIndexParams(): array { if (null !== $this->indexParams) { return $this->indexParams; } $params = []; if ($this->settings) { $params['body']['settings'] = $this->settings; } foreach ($this->provideMappings() as $type => $mapping) { foreach ($mapping as $property => $propertyMapping) { if (!is_array($propertyMapping)) { $propertyMapping = ['type' => $propertyMapping]; } elseif (!isset($propertyMapping['type'])) { $propertyMapping['type'] = self::DEFAULT_PROPERTY_TYPE; } $params['body']['mappings'][$type]['properties'][$property] = $propertyMapping; } } return $this->indexParams = $params; } private function provideMappings(): iterable { foreach ($this->mappings as $type => $mapping) { if (is_string($mapping)) { if (!class_exists($mapping) || !is_subclass_of($mapping, DocumentMappingProviderInterface::class)) { throw new \LogicException(sprintf('The class "%s" does not exists or is not a sub class of "%s".', $mapping, DocumentMappingProviderInterface::class)); } yield from $mapping::provideDocumentMappings(); } else { yield $type => $mapping; } } } } msgphp-0.4.3/src/Domain/Infra/InMemory/000077500000000000000000000000001327361626700176255ustar00rootroot00000000000000msgphp-0.4.3/src/Domain/Infra/InMemory/DomainEntityRepositoryTrait.php000066400000000000000000000121711327361626700260500ustar00rootroot00000000000000 */ trait DomainEntityRepositoryTrait { private $class; private $identityHelper; private $memory; private $accessor; public function __construct(string $class, DomainIdentityHelper $identityHelper, GlobalObjectMemory $memory = null, ObjectFieldAccessor $accessor = null) { $this->class = $class; $this->identityHelper = $identityHelper; $this->memory = $memory ?? GlobalObjectMemory::createDefault(); $this->accessor = $accessor ?? new ObjectFieldAccessor(); } private function doFindAll(int $offset = 0, int $limit = 0): DomainCollectionInterface { return $this->createResultSet(iterator_to_array($this->memory->all($this->class)), $offset, $limit); } private function doFindAllByFields(array $fields, int $offset = 0, int $limit = 0): DomainCollectionInterface { if (!$fields) { throw new \LogicException('No fields provided.'); } $i = -1; $entities = []; foreach ($this->memory->all($this->class) as $entity) { if (!$this->matchesFields($entity, $fields) || ++$i < $offset) { continue; } if ($limit && $i >= ($offset + $limit)) { break; } $entities[] = $entity; } return $this->createResultSet($entities); } /** * @return object */ private function doFind($id) { if (!$this->identityHelper->isIdentity($this->class, $id)) { throw EntityNotFoundException::createForId($this->class, $id); } return $this->doFindByFields($this->identityHelper->toIdentity($this->class, $id)); } /** * @return object */ private function doFindByFields(array $fields) { if ($entity = $this->doFindAllByFields($fields)->first()) { return $entity; } if ($this->identityHelper->isIdentity($this->class, $fields)) { throw EntityNotFoundException::createForId($this->class, $fields); } throw EntityNotFoundException::createForFields($this->class, $fields); } private function doExists($id): bool { if (!$this->identityHelper->isIdentity($this->class, $id)) { return false; } return $this->doExistsByFields($this->identityHelper->toIdentity($this->class, $id)); } private function doExistsByFields(array $fields): bool { try { $this->doFindByFields($fields); return true; } catch (EntityNotFoundException $e) { return false; } } /** * @param object $entity */ private function doSave($entity): void { if (!$entity instanceof $this->class) { throw InvalidClassException::create(get_class($entity)); } if ($this->memory->contains($entity)) { return; } if (null !== ($id = $this->identityHelper->getIdentity($entity)) && $this->doExists($id)) { throw DuplicateEntityException::createForId(get_class($entity), $id); } $this->memory->persist($entity); } /** * @param object $entity */ private function doDelete($entity): void { if (!$entity instanceof $this->class) { throw InvalidClassException::create(get_class($entity)); } $this->memory->remove($entity); } private function createResultSet(array $entities, int $offset = 0, int $limit = 0): DomainCollectionInterface { if ($offset || $limit) { $entities = array_slice($entities, $offset, $limit ?: null); } return DomainCollectionFactory::create($entities); } /** * @param object $entity */ private function matchesFields($entity, array $fields): bool { $idFields = array_flip($this->identityHelper->getIdentifierFieldNames(get_class($entity))); foreach ($fields as $field => $value) { if (isset($idFields[$field]) && $this->identityHelper->isEmptyIdentifier($value)) { return false; } $knownValue = $this->identityHelper->normalizeIdentifier($this->accessor->getValue($entity, $field)); if (is_array($value)) { if (!in_array($knownValue, array_map([$this->identityHelper, 'normalizeIdentifier'], $value)) || in_array(null, $value, true)) { return false; } continue; } $value = $this->identityHelper->normalizeIdentifier($value); if (null === $value xor null === $knownValue) { return false; } if ($value == $knownValue) { continue; } return false; } return true; } } msgphp-0.4.3/src/Domain/Infra/InMemory/DomainIdentityMapping.php000066400000000000000000000030631327361626700245750ustar00rootroot00000000000000 */ final class DomainIdentityMapping implements DomainIdentityMappingInterface { private $mapping; private $accessor; public function __construct(array $mapping, ObjectFieldAccessor $accessor = null) { $this->mapping = $mapping; $this->accessor = $accessor ?? new ObjectFieldAccessor(); } public function getIdentifierFieldNames(string $class): array { if (!isset($this->mapping[$class])) { throw InvalidClassException::create($class); } if (!$fields = (array) $this->mapping[$class]) { throw new \LogicException(sprintf('No identifier fields available for class "%s".', $class)); } return $fields; } public function getIdentity($object): array { $ids = []; foreach ($this->getIdentifierFieldNames(get_class($object)) as $field) { if (null === ($value = $this->accessor->getValue($object, $field))) { continue; } if ($value instanceof DomainIdInterface) { if ($value->isEmpty()) { continue; } } elseif (is_object($value) && !$this->getIdentity($value)) { continue; } $ids[$field] = $value; } return $ids; } } msgphp-0.4.3/src/Domain/Infra/InMemory/GlobalObjectMemory.php000066400000000000000000000021541327361626700240600ustar00rootroot00000000000000storage = new \SplObjectStorage(); } public function all(string $class): iterable { foreach ($this->storage as $k => $object) { if (($stored = $this->storage->getInfo()) === $class || is_subclass_of($stored, $class)) { yield $object; } } } /** * @param object $object */ public function contains($object): bool { return $this->storage->contains($object); } /** * @param object $object */ public function persist($object): void { $this->storage->attach($object, get_class($object)); } /** * @param object $object */ public function remove($object): void { $this->storage->detach($object); } } msgphp-0.4.3/src/Domain/Infra/InMemory/ObjectFieldAccessor.php000066400000000000000000000022101327361626700241660ustar00rootroot00000000000000accessor = $accessor; } /** * @param object $object */ public function getValue($object, string $field) { if (null !== $this->accessor) { return $this->accessor->getValue($object, $field); } // @todo throw on dot/bracket notation (suggest sf/prop-access instead) if (method_exists($object, $method = 'get'.($uc = ucfirst($field))) || method_exists($object, $method = 'has'.$uc) || method_exists($object, $method = 'is'.$uc)) { return $object->$method(); } if (method_exists($object, $field)) { return $object->$field(); } if (property_exists($object, $field)) { return $object->$field; } throw new \RuntimeException(sprintf('Unknown field name "%s" for object "%s".', $field, get_class($object))); } } msgphp-0.4.3/src/Domain/Infra/Messenger/000077500000000000000000000000001327361626700200165ustar00rootroot00000000000000msgphp-0.4.3/src/Domain/Infra/Messenger/ConsoleMessageReceiverBus.php000066400000000000000000000012251327361626700255750ustar00rootroot00000000000000 */ final class ConsoleMessageReceiverBus implements MessageBusInterface { private $bus; private $receiver; public function __construct(MessageBusInterface $bus, MessageReceiver $receiver) { $this->bus = $bus; $this->receiver = $receiver; } public function dispatch($message) { $this->receiver->receive($message); return $this->bus->dispatch($message); } } msgphp-0.4.3/src/Domain/Infra/Messenger/DomainMessageBus.php000066400000000000000000000010221327361626700237100ustar00rootroot00000000000000 */ final class DomainMessageBus implements DomainMessageBusInterface { private $bus; public function __construct(MessageBusInterface $bus) { $this->bus = $bus; } public function dispatch($message) { return $this->bus->dispatch($message); } } msgphp-0.4.3/src/Domain/Infra/SimpleBus/000077500000000000000000000000001327361626700177715ustar00rootroot00000000000000msgphp-0.4.3/src/Domain/Infra/SimpleBus/DomainMessageBus.php000066400000000000000000000010071327361626700236660ustar00rootroot00000000000000 */ final class DomainMessageBus implements DomainMessageBusInterface { private $bus; public function __construct(MessageBus $bus) { $this->bus = $bus; } public function dispatch($message) { $this->bus->handle($message); return null; } } msgphp-0.4.3/src/Domain/Infra/SimpleBus/Middleware/000077500000000000000000000000001327361626700220465ustar00rootroot00000000000000msgphp-0.4.3/src/Domain/Infra/SimpleBus/Middleware/ConsoleMessageReceiverMiddleware.php000066400000000000000000000011451327361626700311520ustar00rootroot00000000000000 */ final class ConsoleMessageReceiverMiddleware implements MessageBusMiddleware { private $receiver; public function __construct(MessageReceiver $receiver) { $this->receiver = $receiver; } public function handle($message, callable $next): void { $this->receiver->receive($message); $next($message); } } msgphp-0.4.3/src/Domain/Infra/Uuid/000077500000000000000000000000001327361626700167745ustar00rootroot00000000000000msgphp-0.4.3/src/Domain/Infra/Uuid/DomainId.php000066400000000000000000000027621327361626700212000ustar00rootroot00000000000000 */ class DomainId implements DomainIdInterface { private $uuid; /** * @return $this|self */ final public static function fromValue($value): DomainIdInterface { if (null !== $value && !$value instanceof UuidInterface) { $value = Uuid::fromString((string) $value); } return new static($value); } final public function __construct(UuidInterface $uuid = null) { $this->uuid = $uuid ?? Uuid::uuid4(); } final public function isEmpty(): bool { return false; } final public function equals(DomainIdInterface $id): bool { return $id === $this ? true : ($id instanceof self && static::class === get_class($id) ? $this->uuid->equals($id->uuid) : false); } final public function toString(): string { return $this->uuid->toString(); } final public function __toString(): string { return $this->uuid->toString(); } final public function serialize(): string { return serialize($this->uuid); } final public function unserialize($serialized): void { $this->uuid = unserialize($serialized); } final public function jsonSerialize(): string { return $this->uuid->jsonSerialize(); } } msgphp-0.4.3/src/Domain/LICENSE000066400000000000000000000020601327361626700160320ustar00rootroot00000000000000MIT License Copyright (c) 2017 Roland Franssen Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. msgphp-0.4.3/src/Domain/Message/000077500000000000000000000000001327361626700164135ustar00rootroot00000000000000msgphp-0.4.3/src/Domain/Message/DomainMessageBusInterface.php000066400000000000000000000004001327361626700241250ustar00rootroot00000000000000 */ interface DomainMessageBusInterface { /** * @param object $message */ public function dispatch($message); } msgphp-0.4.3/src/Domain/Message/FallbackMessageHandler.php000066400000000000000000000007301327361626700234260ustar00rootroot00000000000000 */ final class FallbackMessageHandler { private $bus; public function __construct(DomainMessageBusInterface $bus = null) { $this->bus = $bus; } /** * @param object $message */ public function __invoke($message) { return null === $this->bus ? null : $this->bus->dispatch($message); } } msgphp-0.4.3/src/Domain/Message/MessageDispatchingTrait.php000066400000000000000000000011251327361626700236710ustar00rootroot00000000000000 */ trait MessageDispatchingTrait { private $factory; private $bus; public function __construct(DomainObjectFactoryInterface $factory, DomainMessageBusInterface $bus) { $this->factory = $factory; $this->bus = $bus; } private function dispatch(string $class, array $context = []) { return $this->bus->dispatch($this->factory->create($class, $context)); } } msgphp-0.4.3/src/Domain/Message/MessageReceivingInterface.php000066400000000000000000000004171327361626700241670ustar00rootroot00000000000000 */ interface MessageReceivingInterface { /** * @param object $message */ public function onMessageReceived($message): void; } msgphp-0.4.3/src/Domain/Projection/000077500000000000000000000000001327361626700171435ustar00rootroot00000000000000msgphp-0.4.3/src/Domain/Projection/DomainProjectionDocument.php000066400000000000000000000027161327361626700246250ustar00rootroot00000000000000 */ final class DomainProjectionDocument { public const STATUS_UNKNOWN = 1; public const STATUS_SYNCHRONIZED = 2; public const STATUS_FAILED_TRANSFORMATION = 3; public const STATUS_FAILED_SAVING = 4; /** @var int */ public $status = self::STATUS_UNKNOWN; /** @var object|null */ public $source; /** @var \Throwable|null $error */ public $error; private $type; private $id; private $body = []; public function __construct(string $type = null, string $id = null, array $body = []) { $this->type = $type; $this->id = $id; $this->body = $body; } public function getType(): string { if (null === $this->type) { throw new \LogicException('Document type not set.'); } if (!is_subclass_of($this->type, DomainProjectionInterface::class)) { throw new \LogicException(sprintf('Document type must be a sub class of "%s", got "%s".', DomainProjectionInterface::class, $this->type)); } return $this->type; } public function getId(): ?string { return $this->id; } public function getBody(): array { return $this->body; } public function toProjection(): DomainProjectionInterface { return $this->getType()::fromDocument($this->body); } } msgphp-0.4.3/src/Domain/Projection/DomainProjectionDocumentProvider.php000066400000000000000000000022271327361626700263350ustar00rootroot00000000000000 */ final class DomainProjectionDocumentProvider implements \IteratorAggregate { private $transformer; private $dataProviders; /** * @param callable[] $dataProviders */ public function __construct(DomainProjectionDocumentTransformerInterface $transformer, iterable $dataProviders) { $this->transformer = $transformer; $this->dataProviders = $dataProviders; } public function getIterator(): \Traversable { foreach ($this->dataProviders as $dataProvider) { foreach ($dataProvider() as $object) { try { $document = $this->transformer->transform($object); } catch (\Throwable $e) { $document = new DomainProjectionDocument(); $document->status = DomainProjectionDocument::STATUS_FAILED_TRANSFORMATION; $document->source = $object; $document->error = $e; } yield $document; } } } } msgphp-0.4.3/src/Domain/Projection/DomainProjectionDocumentTransformerInterface.php000066400000000000000000000004571327361626700306710ustar00rootroot00000000000000 */ interface DomainProjectionDocumentTransformerInterface { /** * @param object $object */ public function transform($object): DomainProjectionDocument; } msgphp-0.4.3/src/Domain/Projection/DomainProjectionInterface.php000066400000000000000000000003551327361626700247440ustar00rootroot00000000000000 */ interface DomainProjectionInterface { public static function fromDocument(array $document): self; } msgphp-0.4.3/src/Domain/Projection/DomainProjectionRepositoryInterface.php000066400000000000000000000011131327361626700270350ustar00rootroot00000000000000 */ interface DomainProjectionRepositoryInterface { /** * @return DomainProjectionInterface[] */ public function findAll(string $type, int $offset = 0, int $limit = 0): iterable; public function find(string $type, string $id): ?DomainProjectionInterface; public function clear(string $type): void; public function save(DomainProjectionDocument $document): void; public function delete(string $type, string $id): void; } msgphp-0.4.3/src/Domain/Projection/DomainProjectionSynchronization.php000066400000000000000000000026251327361626700262470ustar00rootroot00000000000000 */ final class DomainProjectionSynchronization { private $typeRegistry; private $repository; private $documentProvider; /** * @param DomainProjectionDocument[] $documentProvider */ public function __construct(DomainProjectionTypeRegistryInterface $typeRegistry, DomainProjectionRepositoryInterface $repository, iterable $documentProvider) { $this->typeRegistry = $typeRegistry; $this->repository = $repository; $this->documentProvider = $documentProvider; } /** * @return DomainProjectionDocument[] */ public function synchronize(): iterable { foreach ($this->typeRegistry->all() as $type) { $this->repository->clear($type); } foreach ($this->documentProvider as $document) { if (DomainProjectionDocument::STATUS_UNKNOWN !== $document->status) { continue; } try { $document->status = DomainProjectionDocument::STATUS_SYNCHRONIZED; $this->repository->save($document); } catch (\Throwable $e) { $document->status = DomainProjectionDocument::STATUS_FAILED_SAVING; $document->error = $e; } yield $document; } } } msgphp-0.4.3/src/Domain/Projection/DomainProjectionTypeRegistryInterface.php000066400000000000000000000005221327361626700273330ustar00rootroot00000000000000 */ interface DomainProjectionTypeRegistryInterface { /** * @return string[] */ public function all(): array; public function initialize(): void; public function destroy(): void; } msgphp-0.4.3/src/Domain/README.md000066400000000000000000000034321327361626700163100ustar00rootroot00000000000000# Base domain layer A base domain layer to rapidly built other domain layers. [![Latest Stable Version](https://poser.pugx.org/msgphp/domain/v/stable)](https://packagist.org/packages/msgphp/domain) This package is part of the _Message driven PHP_ project. > [MsgPHP](https://msgphp.github.io/) is a project that aims to provide (common) message based domain layers for your application. It has a low development time overhead and avoids being overly opinionated. ## Installation ```bash composer require msgphp/domain ``` ## Features - Common entity fields & features - Common domain events - Interface bound collection, identifier, factory & message bus - Abstract entity repositories - Common infrastructure ## Blog posts - [Domain-driven-design: Moving forward with API Platform and Elasticsearch](https://medium.com/@ro0NL/domain-driven-design-moving-forward-with-api-platform-and-elasticsearch-f1705614f9e2) - [Domain-driven-design: Writing domain layers. The fast way.](https://medium.com/@ro0NL/domain-driven-design-writing-domain-layers-the-fast-way-60ef87399374) - [Initializing objects with CLI and the power of Symfony Console](https://medium.com/@ro0NL/initializing-objects-with-cli-and-the-power-of-symfony-console-2a008d5611f) ## Documentation - Read the [main documentation](https://msgphp.github.io/docs/) - Browse the [API documentation](https://msgphp.github.io/api/MsgPhp/Domain.html) - Try the Symfony [demo application](https://github.com/msgphp/symfony-demo-app) - Get support on [Symfony's Slack `#msgphp` channel](https://symfony.com/slack-invite) or [raise an issue](https://github.com/msgphp/msgphp/issues/new) ## Contributing This repository is **READ ONLY**. Issues and pull requests should be submitted in the [main development repository](https://github.com/msgphp/msgphp). msgphp-0.4.3/src/Domain/composer.json000066400000000000000000000025111327361626700175500ustar00rootroot00000000000000{ "name": "msgphp/domain", "type": "library", "license": "MIT", "description": "Base domain layer", "keywords": ["entity"], "authors": [ { "name": "Roland Franssen", "email": "franssen.roland@gmail.com" } ], "minimum-stability": "dev", "autoload": { "psr-4": { "MsgPhp\\Domain\\": "" }, "exclude-from-classmap": ["/Tests/"] }, "require": { "php": "^7.1.0" }, "require-dev": { "api-platform/core": "^2.2", "doctrine/doctrine-bundle": "^1.8", "doctrine/orm": "^2.6", "elasticsearch/elasticsearch": "^6.0", "psr/container": "^1.0", "ramsey/uuid": "^3.7", "ramsey/uuid-doctrine": "^1.4", "simple-bus/message-bus": "^3.0", "symfony/config": "^3.4|^4.0", "symfony/dependency-injection": "^3.4|^4.0", "symfony/http-kernel": "^3.4|^4.0", "symfony/messenger": "^4.1@dev", "symfony/phpunit-bridge": "^3.4|^4.0", "symfony/property-access": "^3.4|^4.0", "symfony/var-dumper": "^3.4|^4.0" }, "config": { "preferred-install": { "*": "dist" }, "sort-packages": true }, "extra": { "branch-alias": { "dev-master": "1.0-dev" } } } msgphp-0.4.3/src/Eav/000077500000000000000000000000001327361626700143335ustar00rootroot00000000000000msgphp-0.4.3/src/Eav/.gitattributes000066400000000000000000000000641327361626700172260ustar00rootroot00000000000000Tests/ export-ignore phpunit.xml.dist export-ignore msgphp-0.4.3/src/Eav/.gitignore000066400000000000000000000000471327361626700163240ustar00rootroot00000000000000/composer.lock /composer.phar /vendor/ msgphp-0.4.3/src/Eav/AttributeId.php000066400000000000000000000003411327361626700172620ustar00rootroot00000000000000 */ final class AttributeId extends DomainId implements AttributeIdInterface { } msgphp-0.4.3/src/Eav/AttributeIdInterface.php000066400000000000000000000003321327361626700211030ustar00rootroot00000000000000 */ interface AttributeIdInterface extends DomainIdInterface { } msgphp-0.4.3/src/Eav/AttributeValueId.php000066400000000000000000000003531327361626700202620ustar00rootroot00000000000000 */ final class AttributeValueId extends DomainId implements AttributeValueIdInterface { } msgphp-0.4.3/src/Eav/AttributeValueIdInterface.php000066400000000000000000000003371327361626700221050ustar00rootroot00000000000000 */ interface AttributeValueIdInterface extends DomainIdInterface { } msgphp-0.4.3/src/Eav/Command/000077500000000000000000000000001327361626700157115ustar00rootroot00000000000000msgphp-0.4.3/src/Eav/Command/CreateAttributeCommand.php000066400000000000000000000004331327361626700230100ustar00rootroot00000000000000 */ class CreateAttributeCommand { public $context; final public function __construct(array $context) { $this->context = $context; } } msgphp-0.4.3/src/Eav/Command/DeleteAttributeCommand.php000066400000000000000000000004451327361626700230120ustar00rootroot00000000000000 */ class DeleteAttributeCommand { public $attributeId; final public function __construct($attributeId) { $this->attributeId = $attributeId; } } msgphp-0.4.3/src/Eav/Command/Handler/000077500000000000000000000000001327361626700172665ustar00rootroot00000000000000msgphp-0.4.3/src/Eav/Command/Handler/CreateAttributeHandler.php000066400000000000000000000021741327361626700243700ustar00rootroot00000000000000 */ final class CreateAttributeHandler { use MessageDispatchingTrait; private $repository; public function __construct(EntityAwareFactoryInterface $factory, DomainMessageBusInterface $bus, AttributeRepositoryInterface $repository) { $this->factory = $factory; $this->bus = $bus; $this->repository = $repository; } public function __invoke(CreateAttributeCommand $command): void { $attribute = $this->factory->create(Attribute::class, $command->context + ['id' => $this->factory->nextIdentifier(Attribute::class)]); $this->repository->save($attribute); $this->dispatch(AttributeCreatedEvent::class, [$attribute]); } } msgphp-0.4.3/src/Eav/Command/Handler/DeleteAttributeHandler.php000066400000000000000000000023641327361626700243700ustar00rootroot00000000000000 */ final class DeleteAttributeHandler { use MessageDispatchingTrait; private $repository; public function __construct(EntityAwareFactoryInterface $factory, DomainMessageBusInterface $bus, AttributeRepositoryInterface $repository) { $this->factory = $factory; $this->bus = $bus; $this->repository = $repository; } public function __invoke(DeleteAttributeCommand $command): void { try { $attribute = $this->repository->find($this->factory->identify(Attribute::class, $command->attributeId)); } catch (EntityNotFoundException $e) { return; } $this->repository->delete($attribute); $this->dispatch(AttributeDeletedEvent::class, [$attribute]); } } msgphp-0.4.3/src/Eav/Entity/000077500000000000000000000000001327361626700156075ustar00rootroot00000000000000msgphp-0.4.3/src/Eav/Entity/Attribute.php000066400000000000000000000003751327361626700202700ustar00rootroot00000000000000 */ abstract class Attribute { abstract public function getId(): AttributeIdInterface; } msgphp-0.4.3/src/Eav/Entity/AttributeValue.php000066400000000000000000000045161327361626700212660ustar00rootroot00000000000000 */ abstract class AttributeValue { private $attribute; private $boolValue; private $intValue; private $floatValue; private $stringValue; private $dateTimeValue; private $checksum; private $value; private $isNull; public function __construct(Attribute $attribute, $value) { $this->attribute = $attribute; $this->changeValue($value); } abstract public function getId(): AttributeValueIdInterface; public function getAttribute(): Attribute { return $this->attribute; } public function getAttributeId(): AttributeIdInterface { return $this->attribute->getId(); } public function getValue() { if ($this->isNull || null !== $this->value) { return $this->value; } if (null === $value = $this->doGetValue()) { $this->isNull = true; } return $this->value = $value; } public function getChecksum(): string { return $this->checksum; } public function changeValue($value): void { $this->isNull = true; $this->boolValue = $this->intValue = $this->floatValue = $this->stringValue = $this->dateTimeValue = $this->value = null; if (null !== $value) { $this->doSetValue($value); $this->value = $value; } $this->checksum = md5(serialize($value)); } protected function doSetValue($value): void { if (is_bool($value)) { $this->boolValue = $value; } elseif (is_int($value)) { $this->intValue = $value; } elseif (is_float($value)) { $this->floatValue = $value; } elseif (is_string($value)) { $this->stringValue = $value; } elseif ($value instanceof \DateTimeInterface) { $this->dateTimeValue = $value; } else { throw new \LogicException(sprintf('Unsupported attribute value type "%s".', gettype($value))); } } protected function doGetValue() { return $this->boolValue ?? $this->intValue ?? $this->floatValue ?? $this->stringValue ?? $this->dateTimeValue; } } msgphp-0.4.3/src/Eav/Entity/Features/000077500000000000000000000000001327361626700173655ustar00rootroot00000000000000msgphp-0.4.3/src/Eav/Entity/Features/EntityAttributeValue.php000066400000000000000000000016111327361626700242320ustar00rootroot00000000000000 */ trait EntityAttributeValue { /** @var AttributeValue */ private $attributeValue; public function getId(): AttributeValueIdInterface { return $this->attributeValue->getId(); } public function getAttribute(): Attribute { return $this->attributeValue->getAttribute(); } public function getAttributeId(): AttributeIdInterface { return $this->attributeValue->getAttributeId(); } public function getValue() { return $this->attributeValue->getValue(); } public function changeValue($value): void { $this->attributeValue->changeValue($value); } } msgphp-0.4.3/src/Eav/Entity/Fields/000077500000000000000000000000001327361626700170155ustar00rootroot00000000000000msgphp-0.4.3/src/Eav/Entity/Fields/AttributesField.php000066400000000000000000000017751327361626700226320ustar00rootroot00000000000000 */ trait AttributesField { /** * @return DomainCollectionInterface|Attribute[] */ public function getAttributes(): DomainCollectionInterface { $attributes = []; foreach ($this->getAttributeValues() as $attributeValue) { $attribute = $attributeValue->getAttribute(); if (isset($attributes[$attributeId = $attribute->getId()->toString()])) { continue; } $attributes[$attributeId] = $attribute; } return DomainCollectionFactory::create(array_values($attributes)); } /** * @return DomainCollectionInterface|AttributeValue[] */ abstract public function getAttributeValues(): DomainCollectionInterface; } msgphp-0.4.3/src/Eav/Event/000077500000000000000000000000001327361626700154145ustar00rootroot00000000000000msgphp-0.4.3/src/Eav/Event/AttributeCreatedEvent.php000066400000000000000000000005061327361626700223630ustar00rootroot00000000000000 */ class AttributeCreatedEvent { public $attribute; final public function __construct(Attribute $attribute) { $this->attribute = $attribute; } } msgphp-0.4.3/src/Eav/Event/AttributeDeletedEvent.php000066400000000000000000000005061327361626700223620ustar00rootroot00000000000000 */ class AttributeDeletedEvent { public $attribute; final public function __construct(Attribute $attribute) { $this->attribute = $attribute; } } msgphp-0.4.3/src/Eav/Infra/000077500000000000000000000000001327361626700153725ustar00rootroot00000000000000msgphp-0.4.3/src/Eav/Infra/Doctrine/000077500000000000000000000000001327361626700171415ustar00rootroot00000000000000msgphp-0.4.3/src/Eav/Infra/Doctrine/EntityFieldsMapping.php000066400000000000000000000015441327361626700235750ustar00rootroot00000000000000 * * @internal */ final class EntityFieldsMapping implements ObjectFieldMappingProviderInterface { public static function getObjectFieldMapping(): array { return [ Features\EntityAttributeValue::class => [ 'attributeValue' => [ 'type' => self::TYPE_ONE_TO_ONE, 'targetEntity' => AttributeValue::class, 'cascade' => ['all'], 'joinColumns' => [ ['nullable' => false, 'onDelete' => 'CASCADE'], ], ], ], ]; } } msgphp-0.4.3/src/Eav/Infra/Doctrine/Repository/000077500000000000000000000000001327361626700213205ustar00rootroot00000000000000msgphp-0.4.3/src/Eav/Infra/Doctrine/Repository/AttributeRepository.php000066400000000000000000000022241327361626700260740ustar00rootroot00000000000000 */ final class AttributeRepository implements AttributeRepositoryInterface { use DomainEntityRepositoryTrait; private $alias = 'attribute'; /** * @return DomainCollectionInterface|Attribute[] */ public function findAll(int $offset = 0, int $limit = 0): DomainCollectionInterface { return $this->doFindAll($offset, $limit); } public function find(AttributeIdInterface $id): Attribute { return $this->doFind($id); } public function exists(AttributeIdInterface $id): bool { return $this->doExists($id); } public function save(Attribute $attribute): void { $this->doSave($attribute); } public function delete(Attribute $attribute): void { $this->doDelete($attribute); } } msgphp-0.4.3/src/Eav/Infra/Doctrine/Repository/EntityAttributeValueRepositoryTrait.php000066400000000000000000000020421327361626700312700ustar00rootroot00000000000000 */ trait EntityAttributeValueRepositoryTrait { use DomainEntityRepositoryTrait; private function addAttributeCriteria(QueryBuilder $qb, AttributeIdInterface $attributeId, $value = null, string $alias = null): void { $field = ($this->alias ?? $alias).'.'.$this->attributeValueField; if (3 === func_num_args()) { $qb->join($field, 'attribute_value', Join::WITH, 'attribute_value.checksum = '.$this->addFieldParameter($qb, $this->attributeValueField, md5(serialize($value)))); } else { $qb->join($field, 'attribute_value'); } $qb->join('attribute_value.attribute', 'attribute', Join::WITH, 'attribute.id = '.$this->addFieldParameter($qb, 'attribute', $attributeId)); } } msgphp-0.4.3/src/Eav/Infra/Doctrine/Resources/000077500000000000000000000000001327361626700211135ustar00rootroot00000000000000msgphp-0.4.3/src/Eav/Infra/Doctrine/Resources/dist-mapping/000077500000000000000000000000001327361626700235075ustar00rootroot00000000000000msgphp-0.4.3/src/Eav/Infra/Doctrine/Resources/dist-mapping/Eav.Entity.Attribute.orm.xml000066400000000000000000000006271327361626700307620ustar00rootroot00000000000000 msgphp-0.4.3/src/Eav/Infra/Doctrine/Resources/dist-mapping/Eav.Entity.AttributeValue.orm.xml000066400000000000000000000017161327361626700317570ustar00rootroot00000000000000 msgphp-0.4.3/src/Eav/Infra/Doctrine/Type/000077500000000000000000000000001327361626700200625ustar00rootroot00000000000000msgphp-0.4.3/src/Eav/Infra/Doctrine/Type/AttributeIdType.php000066400000000000000000000004371327361626700236610ustar00rootroot00000000000000 */ final class AttributeIdType extends DomainIdType { public const NAME = 'msgphp_attribute_id'; } msgphp-0.4.3/src/Eav/Infra/Doctrine/Type/AttributeValueIdType.php000066400000000000000000000004521327361626700246530ustar00rootroot00000000000000 */ final class AttributeValueIdType extends DomainIdType { public const NAME = 'msgphp_attribute_value_id'; } msgphp-0.4.3/src/Eav/Infra/Uuid/000077500000000000000000000000001327361626700163005ustar00rootroot00000000000000msgphp-0.4.3/src/Eav/Infra/Uuid/AttributeId.php000066400000000000000000000004341327361626700212320ustar00rootroot00000000000000 */ final class AttributeId extends DomainId implements AttributeIdInterface { } msgphp-0.4.3/src/Eav/Infra/Uuid/AttributeValueId.php000066400000000000000000000004531327361626700222300ustar00rootroot00000000000000 */ final class AttributeValueId extends DomainId implements AttributeValueIdInterface { } msgphp-0.4.3/src/Eav/LICENSE000066400000000000000000000020601327361626700153360ustar00rootroot00000000000000MIT License Copyright (c) 2017 Roland Franssen Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. msgphp-0.4.3/src/Eav/README.md000066400000000000000000000024431327361626700156150ustar00rootroot00000000000000# Entity-Attribute-Value domain layer A domain layer providing basic [EAV](https://en.wikipedia.org/wiki/Entity%E2%80%93attribute%E2%80%93value_model) management. [![Latest Stable Version](https://poser.pugx.org/msgphp/eav/v/stable)](https://packagist.org/packages/msgphp/eav) This package is part of the _Message driven PHP_ project. > [MsgPHP](https://msgphp.github.io/) is a project that aims to provide (common) message based domain layers for your application. It has a low development time overhead and avoids being overly opinionated. ## Installation ```bash composer require msgphp/eav ``` ## Features - Doctrine persistence - Standard supported attribute value types: `bool`, `int`, `float`, `string`, `\DateTimeInterface` and `null` ## Documentation - Read the [main documentation](https://msgphp.github.io/docs/) - Browse the [API documentation](https://msgphp.github.io/api/MsgPhp/Eav.html) - Try the Symfony [demo application](https://github.com/msgphp/symfony-demo-app) - Get support on [Symfony's Slack `#msgphp` channel](https://symfony.com/slack-invite) or [raise an issue](https://github.com/msgphp/msgphp/issues/new) ## Contributing This repository is **READ ONLY**. Issues and pull requests should be submitted in the [main development repository](https://github.com/msgphp/msgphp). msgphp-0.4.3/src/Eav/Repository/000077500000000000000000000000001327361626700165125ustar00rootroot00000000000000msgphp-0.4.3/src/Eav/Repository/AttributeRepositoryInterface.php000066400000000000000000000012541327361626700251110ustar00rootroot00000000000000 */ interface AttributeRepositoryInterface { /** * @return DomainCollectionInterface|Attribute[] */ public function findAll(int $offset = 0, int $limit = 0): DomainCollectionInterface; public function find(AttributeIdInterface $id): Attribute; public function exists(AttributeIdInterface $id): bool; public function save(Attribute $attribute): void; public function delete(Attribute $attribute): void; } msgphp-0.4.3/src/Eav/composer.json000066400000000000000000000016451327361626700170630ustar00rootroot00000000000000{ "name": "msgphp/eav", "type": "library", "license": "MIT", "description": "Entity-Attribute-Value domain layer", "keywords": ["entity-attribute-value", "eav"], "authors": [ { "name": "Roland Franssen", "email": "franssen.roland@gmail.com" } ], "minimum-stability": "dev", "autoload": { "psr-4": { "MsgPhp\\Eav\\": "" }, "exclude-from-classmap": ["/Tests/"] }, "require": { "msgphp/domain": "^0.4|^1.0" }, "require-dev": { "doctrine/orm": "^2.6", "ramsey/uuid": "^3.7", "symfony/phpunit-bridge": "^3.4|^4.0", "symfony/var-dumper": "^3.4|^4.0" }, "config": { "preferred-install": { "*": "dist" }, "sort-packages": true }, "extra": { "branch-alias": { "dev-master": "1.0-dev" } } } msgphp-0.4.3/src/EavBundle/000077500000000000000000000000001327361626700154655ustar00rootroot00000000000000msgphp-0.4.3/src/EavBundle/.gitattributes000066400000000000000000000000641327361626700203600ustar00rootroot00000000000000Tests/ export-ignore phpunit.xml.dist export-ignore msgphp-0.4.3/src/EavBundle/.gitignore000066400000000000000000000000471327361626700174560ustar00rootroot00000000000000/composer.lock /composer.phar /vendor/ msgphp-0.4.3/src/EavBundle/DependencyInjection/000077500000000000000000000000001327361626700214065ustar00rootroot00000000000000msgphp-0.4.3/src/EavBundle/DependencyInjection/Compiler/000077500000000000000000000000001327361626700231605ustar00rootroot00000000000000msgphp-0.4.3/src/EavBundle/DependencyInjection/Compiler/CleanupPass.php000066400000000000000000000024161327361626700261120ustar00rootroot00000000000000 * * @internal */ final class CleanupPass implements CompilerPassInterface { public function process(ContainerBuilder $container): void { $doctrineRepositoryIds = []; foreach (glob(Configuration::getPackageDir().'/Infra/Doctrine/Repository/*Repository.php') as $file) { $doctrineRepositoryIds[] = 'MsgPhp\\User\\Infra\\Doctrine\\Repository\\'.basename($file, '.php'); } ContainerHelper::removeIf($container, !$container->has(DoctrineEntityManager::class), $doctrineRepositoryIds); ContainerHelper::removeIf($container, !$container->has(Repository\AttributeRepositoryInterface::class), [ Command\Handler\CreateAttributeHandler::class, Command\Handler\DeleteAttributeHandler::class, ]); } } msgphp-0.4.3/src/EavBundle/DependencyInjection/Configuration.php000066400000000000000000000060601327361626700247300ustar00rootroot00000000000000 * * @internal */ final class Configuration implements ConfigurationInterface { public const AGGREGATE_ROOTS = [ Entity\Attribute::class => AttributeIdInterface::class, Entity\AttributeValue::class => AttributeValueIdInterface::class, ]; public const IDENTITY_MAPPING = [ Entity\Attribute::class => ['id'], Entity\AttributeValue::class => ['id'], ]; public const DEFAULT_ID_CLASS_MAPPING = [ AttributeIdInterface::class => AttributeId::class, AttributeValueIdInterface::class => AttributeValueId::class, ]; public const UUID_CLASS_MAPPING = [ AttributeIdInterface::class => UuidInfra\AttributeId::class, AttributeValueIdInterface::class => UuidInfra\AttributeValueId::class, ]; private const COMMAND_MAPPING = [ Entity\Attribute::class => [ Command\CreateAttributeCommand::class => true, Command\DeleteAttributeCommand::class => true, ], ]; public static function getPackageDir(): string { static $path; if (null === $path) { $path = dirname((new \ReflectionClass(AttributeIdInterface::class))->getFileName()); } return $path; } public function getConfigTreeBuilder(): TreeBuilder { /** @var NodeBuilder $children */ $children = ($treeBuilder = new TreeBuilder())->rootArray(Extension::ALIAS)->children(); $children ->classMappingNode('class_mapping') ->requireClasses([Entity\Attribute::class, Entity\AttributeValue::class]) ->subClassValues() ->end() ->classMappingNode('id_type_mapping') ->subClassKeys([DomainIdInterface::class]) ->end() ->classMappingNode('commands') ->typeOfValues('boolean') ->end() ->scalarNode('default_id_type') ->defaultValue(ConfigHelper::DEFAULT_ID_TYPE) ->cannotBeEmpty() ->end() ->end() ->validate() ->always(ConfigHelper::defaultBundleConfig( self::DEFAULT_ID_CLASS_MAPPING, array_fill_keys(ConfigHelper::UUID_TYPES, self::UUID_CLASS_MAPPING) )) ->end() ->validate() ->always(function (array $config): array { ConfigHelper::resolveCommandMappingConfig(self::COMMAND_MAPPING, $config['class_mapping'], $config['commands']); return $config; }) ->end(); return $treeBuilder; } } msgphp-0.4.3/src/EavBundle/DependencyInjection/Extension.php000066400000000000000000000075721327361626700241060ustar00rootroot00000000000000 * * @internal */ final class Extension extends BaseExtension implements PrependExtensionInterface, CompilerPassInterface { public const ALIAS = 'msgphp_eav'; public function getAlias(): string { return self::ALIAS; } public function getConfiguration(array $config, ContainerBuilder $container): ConfigurationInterface { return new Configuration(); } public function load(array $configs, ContainerBuilder $container): void { $loader = new PhpFileLoader($container, new FileLocator(dirname(__DIR__).'/Resources/config')); $config = $this->processConfiguration($this->getConfiguration($configs, $container), $configs); // default infra ContainerHelper::configureIdentityMapping($container, $config['class_mapping'], Configuration::IDENTITY_MAPPING); ContainerHelper::configureEntityFactory($container, $config['class_mapping'], Configuration::AGGREGATE_ROOTS); // message infra $loader->load('message.php'); ContainerHelper::configureCommandMessages($container, $config['class_mapping'], $config['commands']); ContainerHelper::configureEventMessages($container, $config['class_mapping'], array_map(function (string $file): string { return 'MsgPhp\\Eav\\Event\\'.basename($file, '.php'); }, glob(Configuration::getPackageDir().'/Event/*Event.php'))); // persistence infra if (class_exists(DoctrineOrmVersion::class)) { $this->loadDoctrineOrm($config, $loader, $container); } } public function prepend(ContainerBuilder $container): void { $config = $this->processConfiguration($this->getConfiguration($configs = $container->getExtensionConfig($this->getAlias()), $container), $configs); ContainerHelper::configureDoctrineDbalTypes($container, $config['class_mapping'], $config['id_type_mapping'], [ AttributeIdInterface::class => DoctrineInfra\Type\AttributeIdType::class, AttributeValueIdInterface::class => DoctrineInfra\Type\AttributeValueIdType::class, ]); ContainerHelper::configureDoctrineOrmTargetEntities($container, $config['class_mapping']); } public function process(ContainerBuilder $container): void { } private function loadDoctrineOrm(array $config, LoaderInterface $loader, ContainerBuilder $container): void { $loader->load('doctrine.php'); ContainerHelper::configureDoctrineOrmMapping($container, self::getDoctrineMappingFiles($config, $container), [DoctrineInfra\EntityFieldsMapping::class]); ContainerHelper::configureDoctrineOrmRepositories($container, $config['class_mapping'], [ DoctrineInfra\Repository\AttributeRepository::class => Entity\Attribute::class, ]); } private static function getDoctrineMappingFiles(array $config, ContainerBuilder $container): array { $baseDir = Configuration::getPackageDir().'/Infra/Doctrine/Resources/dist-mapping'; return glob($baseDir.'/*.orm.xml'); } } msgphp-0.4.3/src/EavBundle/LICENSE000066400000000000000000000020601327361626700164700ustar00rootroot00000000000000MIT License Copyright (c) 2017 Roland Franssen Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. msgphp-0.4.3/src/EavBundle/MsgPhpEavBundle.php000066400000000000000000000017621327361626700211700ustar00rootroot00000000000000 */ final class MsgPhpEavBundle extends Bundle { public function boot(): void { BundleHelper::boot($this->container); } public function build(ContainerBuilder $container): void { $container->addCompilerPass(new CleanupPass(), PassConfig::TYPE_BEFORE_OPTIMIZATION, 100); BundleHelper::initDomain($container); } public function getContainerExtension(): ?ExtensionInterface { return new Extension(); } } msgphp-0.4.3/src/EavBundle/README.md000066400000000000000000000045271327361626700167540ustar00rootroot00000000000000# Entity-Attribute-Value bundle A Symfony bundle for basic [EAV](https://en.wikipedia.org/wiki/Entity%E2%80%93attribute%E2%80%93value_model) management. [![Latest Stable Version](https://poser.pugx.org/msgphp/eav-bundle/v/stable)](https://packagist.org/packages/msgphp/eav-bundle) This package is part of the _Message driven PHP_ project. > [MsgPHP](https://msgphp.github.io/) is a project that aims to provide (common) message based domain layers for your application. It has a low development time overhead and avoids being overly opinionated. ## Installation ```bash composer require msgphp/eav-bundle ``` ## Features - Symfony 3.4 / 4.0 ready - Doctrine persistence - Standard supported attribute value types: `bool`, `int`, `float`, `string`, `\DateTimeInterface` and `null` ## Configuration ```php extension('msgphp_eav', [ 'class_mapping' => [ Attribute::class => \App\Entity\Eav\Attribute::class, AttributeValue::class => \App\Entity\Eav\AttributeValue::class, ], ]); }; ``` And be done. ## Usage ### With [`DoctrineBundle`](https://github.com/doctrine/DoctrineBundle) Repositories from `MsgPhp\Eav\Infra\Doctrine\Repository\*` are registered as a service. Corresponding domain interfaces from `MsgPhp\Eav\Repository\*` are aliased. Minimal configuration: ```yaml # config/packages/doctrine.yaml doctrine: orm: mappings: app: dir: '%kernel.project_dir%/src/Entity' type: annotation prefix: App\Entity ``` - Requires `doctrine/orm` ## Documentation - Read the [main documentation](https://msgphp.github.io/docs/) - Browse the [API documentation](https://msgphp.github.io/api/MsgPhp/EavBundle.html) - Try the Symfony [demo application](https://github.com/msgphp/symfony-demo-app) - Get support on [Symfony's Slack `#msgphp` channel](https://symfony.com/slack-invite) or [raise an issue](https://github.com/msgphp/msgphp/issues/new) ## Contributing This repository is **READ ONLY**. Issues and pull requests should be submitted in the [main development repository](https://github.com/msgphp/msgphp). msgphp-0.4.3/src/EavBundle/Resources/000077500000000000000000000000001327361626700174375ustar00rootroot00000000000000msgphp-0.4.3/src/EavBundle/Resources/config/000077500000000000000000000000001327361626700207045ustar00rootroot00000000000000msgphp-0.4.3/src/EavBundle/Resources/config/doctrine.php000066400000000000000000000007371327361626700232330ustar00rootroot00000000000000services() ->defaults() ->autowire() ->private() ->load('MsgPhp\\Eav\\Infra\\Doctrine\\Repository\\', Configuration::getPackageDir().'/Infra/Doctrine/Repository/*Repository.php') ; }; msgphp-0.4.3/src/EavBundle/Resources/config/message.php000066400000000000000000000007721327361626700230470ustar00rootroot00000000000000services() ->defaults() ->autowire() ->private() ->load('MsgPhp\\Eav\\Command\\Handler\\', Configuration::getPackageDir().'/Command/Handler/*Handler.php') ->tag('msgphp.domain.command_handler') ; }; msgphp-0.4.3/src/EavBundle/composer.json000066400000000000000000000021421327361626700202060ustar00rootroot00000000000000{ "name": "msgphp/eav-bundle", "type": "symfony-bundle", "license": "MIT", "description": "Basic entity-attribute-value management (the `EAV` domain)", "keywords": ["entity-attribute-value", "eav"], "authors": [ { "name": "Roland Franssen", "email": "franssen.roland@gmail.com" } ], "minimum-stability": "dev", "autoload": { "psr-4": { "MsgPhp\\EavBundle\\": "" }, "exclude-from-classmap": ["/Tests/"] }, "require": { "msgphp/eav": "^0.4|^1.0", "symfony/config": "^3.4|^4.0", "symfony/dependency-injection": "^3.4|^4.0", "symfony/http-kernel": "^3.4|^4.0" }, "require-dev": { "doctrine/doctrine-bundle": "^1.8", "doctrine/orm": "^2.6", "symfony/phpunit-bridge": "^3.4|^4.0", "symfony/var-dumper": "^3.4|^4.0" }, "config": { "preferred-install": { "*": "dist" }, "sort-packages": true }, "extra": { "branch-alias": { "dev-master": "1.0-dev" } } } msgphp-0.4.3/src/User/000077500000000000000000000000001327361626700145365ustar00rootroot00000000000000msgphp-0.4.3/src/User/.gitattributes000066400000000000000000000000641327361626700174310ustar00rootroot00000000000000Tests/ export-ignore phpunit.xml.dist export-ignore msgphp-0.4.3/src/User/.gitignore000066400000000000000000000000471327361626700165270ustar00rootroot00000000000000/composer.lock /composer.phar /vendor/ msgphp-0.4.3/src/User/Command/000077500000000000000000000000001327361626700161145ustar00rootroot00000000000000msgphp-0.4.3/src/User/Command/AddUserAttributeValueCommand.php000066400000000000000000000007611327361626700243400ustar00rootroot00000000000000 */ class AddUserAttributeValueCommand { public $userId; public $attributeId; public $value; public $context; final public function __construct($userId, $attributeId, $value, array $context = []) { $this->userId = $userId; $this->attributeId = $attributeId; $this->value = $value; $this->context = $context; } } msgphp-0.4.3/src/User/Command/AddUserEmailCommand.php000066400000000000000000000006351327361626700224270ustar00rootroot00000000000000 */ class AddUserEmailCommand { public $userId; public $email; public $context; final public function __construct($userId, string $email, array $context = []) { $this->userId = $userId; $this->email = $email; $this->context = $context; } } msgphp-0.4.3/src/User/Command/AddUserRoleCommand.php000066400000000000000000000006501327361626700222760ustar00rootroot00000000000000 */ class AddUserRoleCommand { public $userId; public $roleName; public $context; final public function __construct($userId, string $roleName, array $context = []) { $this->userId = $userId; $this->roleName = $roleName; $this->context = $context; } } msgphp-0.4.3/src/User/Command/ChangeUserAttributeValueCommand.php000066400000000000000000000005051327361626700250310ustar00rootroot00000000000000 */ class ChangeUserAttributeValueCommand { public $id; public $value; final public function __construct($id, $value) { $this->id = $id; $this->value = $value; } } msgphp-0.4.3/src/User/Command/ChangeUserCredentialCommand.php000066400000000000000000000005371327361626700241500ustar00rootroot00000000000000 */ class ChangeUserCredentialCommand { public $userId; public $context; final public function __construct($userId, array $context) { $this->userId = $userId; $this->context = $context; } } msgphp-0.4.3/src/User/Command/ConfirmUserCommand.php000066400000000000000000000004161327361626700223610ustar00rootroot00000000000000 */ class ConfirmUserCommand { public $userId; final public function __construct($userId) { $this->userId = $userId; } } msgphp-0.4.3/src/User/Command/ConfirmUserEmailCommand.php000066400000000000000000000004261327361626700233320ustar00rootroot00000000000000 */ class ConfirmUserEmailCommand { public $email; final public function __construct(string $email) { $this->email = $email; } } msgphp-0.4.3/src/User/Command/CreateUserCommand.php000066400000000000000000000004271327361626700221710ustar00rootroot00000000000000 */ class CreateUserCommand { public $context; final public function __construct(array $context) { $this->context = $context; } } msgphp-0.4.3/src/User/Command/DeleteUserAttributeValueCommand.php000066400000000000000000000004131327361626700250440ustar00rootroot00000000000000 */ class DeleteUserAttributeValueCommand { public $id; final public function __construct($id) { $this->id = $id; } } msgphp-0.4.3/src/User/Command/DeleteUserCommand.php000066400000000000000000000004151327361626700221650ustar00rootroot00000000000000 */ class DeleteUserCommand { public $userId; final public function __construct($userId) { $this->userId = $userId; } } msgphp-0.4.3/src/User/Command/DeleteUserEmailCommand.php000066400000000000000000000004251327361626700231360ustar00rootroot00000000000000 */ class DeleteUserEmailCommand { public $email; final public function __construct(string $email) { $this->email = $email; } } msgphp-0.4.3/src/User/Command/DeleteUserRoleCommand.php000066400000000000000000000005361327361626700230130ustar00rootroot00000000000000 */ class DeleteUserRoleCommand { public $userId; public $roleName; final public function __construct($userId, string $roleName) { $this->userId = $userId; $this->roleName = $roleName; } } msgphp-0.4.3/src/User/Command/DisableUserCommand.php000066400000000000000000000004161327361626700223270ustar00rootroot00000000000000 */ class DisableUserCommand { public $userId; final public function __construct($userId) { $this->userId = $userId; } } msgphp-0.4.3/src/User/Command/EnableUserCommand.php000066400000000000000000000004151327361626700221510ustar00rootroot00000000000000 */ class EnableUserCommand { public $userId; final public function __construct($userId) { $this->userId = $userId; } } msgphp-0.4.3/src/User/Command/Handler/000077500000000000000000000000001327361626700174715ustar00rootroot00000000000000msgphp-0.4.3/src/User/Command/Handler/AddUserAttributeValueHandler.php000066400000000000000000000034771327361626700257230ustar00rootroot00000000000000 */ final class AddUserAttributeValueHandler { use MessageDispatchingTrait; private $repository; public function __construct(EntityAwareFactoryInterface $factory, DomainMessageBusInterface $bus, UserAttributeValueRepositoryInterface $repository) { $this->factory = $factory; $this->bus = $bus; $this->repository = $repository; } public function __invoke(AddUserAttributeValueCommand $command): void { $attributeValueContext = $command->context['attributeValue'] ?? $command->context['attribute_value'] ?? []; $attributeValueContext += ['id' => $this->factory->nextIdentifier(AttributeValue::class)]; $userAttributeValue = $this->factory->create(UserAttributeValue::class, [ 'user' => $this->factory->reference(User::class, $this->factory->identify(User::class, $command->userId)), 'attributeValue' => [ 'attribute' => $this->factory->reference(Attribute::class, $this->factory->identify(Attribute::class, $command->attributeId)), 'value' => $command->value, ] + $attributeValueContext, ] + $command->context); $this->repository->save($userAttributeValue); $this->dispatch(UserAttributeValueAddedEvent::class, [$userAttributeValue]); } } msgphp-0.4.3/src/User/Command/Handler/AddUserEmailHandler.php000066400000000000000000000024071327361626700240020ustar00rootroot00000000000000 */ final class AddUserEmailHandler { use MessageDispatchingTrait; private $repository; public function __construct(EntityAwareFactoryInterface $factory, DomainMessageBusInterface $bus, UserEmailRepositoryInterface $repository) { $this->factory = $factory; $this->bus = $bus; $this->repository = $repository; } public function __invoke(AddUserEmailCommand $command): void { $userId = $this->factory->identify(User::class, $command->userId); $userEmail = $this->factory->create(UserEmail::class, [ 'user' => $this->factory->reference(User::class, $userId), 'email' => $command->email, ] + $command->context); $this->repository->save($userEmail); $this->dispatch(UserEmailAddedEvent::class, [$userEmail]); } } msgphp-0.4.3/src/User/Command/Handler/AddUserRoleHandler.php000066400000000000000000000024201327361626700236470ustar00rootroot00000000000000 */ final class AddUserRoleHandler { use MessageDispatchingTrait; private $repository; public function __construct(EntityAwareFactoryInterface $factory, DomainMessageBusInterface $bus, UserRoleRepositoryInterface $repository) { $this->factory = $factory; $this->bus = $bus; $this->repository = $repository; } public function __invoke(AddUserRoleCommand $command): void { $userRole = $this->factory->create(UserRole::class, [ 'user' => $this->factory->reference(User::class, $this->factory->identify(User::class, $command->userId)), 'role' => $this->factory->reference(Role::class, $command->roleName), ] + $command->context); $this->repository->save($userRole); $this->dispatch(UserRoleAddedEvent::class, [$userRole]); } } msgphp-0.4.3/src/User/Command/Handler/ChangeUserAttributeValueHandler.php000066400000000000000000000027251327361626700264130ustar00rootroot00000000000000 */ final class ChangeUserAttributeValueHandler { use MessageDispatchingTrait; private $repository; public function __construct(EntityAwareFactoryInterface $factory, DomainMessageBusInterface $bus, UserAttributeValueRepositoryInterface $repository) { $this->factory = $factory; $this->bus = $bus; $this->repository = $repository; } public function __invoke(ChangeUserAttributeValueCommand $command): void { // @fixme configure factory to handle `UserAttributeValue::class` as well $userAttributeValue = $this->repository->find($this->factory->identify(AttributeValue::class, $command->id)); if ($command->value === $oldValue = $userAttributeValue->getValue()) { return; } $userAttributeValue->changeValue($command->value); $this->repository->save($userAttributeValue); $this->dispatch(UserAttributeValueChangedEvent::class, [$userAttributeValue, $oldValue, $command->value]); } } msgphp-0.4.3/src/User/Command/Handler/ChangeUserCredentialHandler.php000066400000000000000000000033761327361626700255300ustar00rootroot00000000000000 */ final class ChangeUserCredentialHandler { use EventSourcingCommandHandlerTrait; use MessageDispatchingTrait; private $repository; public function __construct(EntityAwareFactoryInterface $factory, DomainMessageBusInterface $bus, UserRepositoryInterface $repository) { $this->factory = $factory; $this->bus = $bus; $this->repository = $repository; } public function __invoke(ChangeUserCredentialCommand $command): void { $oldCredential = $this->getDomainEventHandler($command)->getCredential(); $this->handle($command, function (User $user) use ($oldCredential): void { $this->repository->save($user); $this->dispatch(UserCredentialChangedEvent::class, [$user, $oldCredential, $user->getCredential()]); }); } protected function getDomainEvent(ChangeUserCredentialCommand $command): ChangeCredentialEvent { return $this->factory->create(ChangeCredentialEvent::class, [$command->context]); } protected function getDomainEventHandler(ChangeUserCredentialCommand $command): User { return $this->repository->find($this->factory->identify(User::class, $command->userId)); } } msgphp-0.4.3/src/User/Command/Handler/ConfirmUserEmailHandler.php000066400000000000000000000030371327361626700247070ustar00rootroot00000000000000 */ final class ConfirmUserEmailHandler { use EventSourcingCommandHandlerTrait; use MessageDispatchingTrait; private $repository; public function __construct(EntityAwareFactoryInterface $factory, DomainMessageBusInterface $bus, UserEmailRepositoryInterface $repository) { $this->factory = $factory; $this->bus = $bus; $this->repository = $repository; } public function __invoke(ConfirmUserEmailCommand $command): void { $this->handle($command, function (UserEmail $userEmail): void { $this->repository->save($userEmail); $this->dispatch(UserEmailConfirmedEvent::class, [$userEmail]); }); } protected function getDomainEvent(ConfirmUserEmailCommand $command): ConfirmEvent { return $this->factory->create(ConfirmEvent::class); } protected function getDomainEventHandler(ConfirmUserEmailCommand $command): UserEmail { return $this->repository->find($command->email); } } msgphp-0.4.3/src/User/Command/Handler/ConfirmUserHandler.php000066400000000000000000000027741327361626700237460ustar00rootroot00000000000000 */ final class ConfirmUserHandler { use EventSourcingCommandHandlerTrait; use MessageDispatchingTrait; private $repository; public function __construct(EntityAwareFactoryInterface $factory, DomainMessageBusInterface $bus, UserRepositoryInterface $repository) { $this->factory = $factory; $this->bus = $bus; $this->repository = $repository; } public function __invoke(ConfirmUserCommand $command): void { $this->handle($command, function (User $user): void { $this->repository->save($user); $this->dispatch(UserConfirmedEvent::class, [$user]); }); } protected function getDomainEvent(ConfirmUserCommand $command): ConfirmEvent { return $this->factory->create(ConfirmEvent::class); } protected function getDomainEventHandler(ConfirmUserCommand $command): User { return $this->repository->find($this->factory->identify(User::class, $command->userId)); } } msgphp-0.4.3/src/User/Command/Handler/CreateUserHandler.php000066400000000000000000000021001327361626700235330ustar00rootroot00000000000000 */ final class CreateUserHandler { use MessageDispatchingTrait; private $repository; public function __construct(EntityAwareFactoryInterface $factory, DomainMessageBusInterface $bus, UserRepositoryInterface $repository) { $this->factory = $factory; $this->bus = $bus; $this->repository = $repository; } public function __invoke(CreateUserCommand $command): void { $user = $this->factory->create(User::class, $command->context + ['id' => $this->factory->nextIdentifier(User::class)]); $this->repository->save($user); $this->dispatch(UserCreatedEvent::class, [$user]); } } msgphp-0.4.3/src/User/Command/Handler/DeleteUserAttributeValueHandler.php000066400000000000000000000025231327361626700264240ustar00rootroot00000000000000 */ final class DeleteUserAttributeValueHandler { use MessageDispatchingTrait; private $repository; public function __construct(EntityAwareFactoryInterface $factory, DomainMessageBusInterface $bus, UserAttributeValueRepositoryInterface $repository) { $this->factory = $factory; $this->bus = $bus; $this->repository = $repository; } public function __invoke(DeleteUserAttributeValueCommand $command): void { try { $userAttributeValue = $this->repository->find($this->factory->identify(AttributeValue::class, $command->id)); } catch (EntityNotFoundException $e) { return; } $this->repository->delete($userAttributeValue); $this->dispatch(UserAttributeValueDeletedEvent::class, [$userAttributeValue]); } } msgphp-0.4.3/src/User/Command/Handler/DeleteUserEmailHandler.php000066400000000000000000000022451327361626700245140ustar00rootroot00000000000000 */ final class DeleteUserEmailHandler { use MessageDispatchingTrait; private $repository; public function __construct(EntityAwareFactoryInterface $factory, DomainMessageBusInterface $bus, UserEmailRepositoryInterface $repository) { $this->factory = $factory; $this->bus = $bus; $this->repository = $repository; } public function __invoke(DeleteUserEmailCommand $command): void { try { $userEmail = $this->repository->find($command->email); } catch (EntityNotFoundException $e) { return; } $this->repository->delete($userEmail); $this->dispatch(UserEmailDeletedEvent::class, [$userEmail]); } } msgphp-0.4.3/src/User/Command/Handler/DeleteUserHandler.php000066400000000000000000000022701327361626700235420ustar00rootroot00000000000000 */ final class DeleteUserHandler { use MessageDispatchingTrait; private $repository; public function __construct(EntityAwareFactoryInterface $factory, DomainMessageBusInterface $bus, UserRepositoryInterface $repository) { $this->factory = $factory; $this->bus = $bus; $this->repository = $repository; } public function __invoke(DeleteUserCommand $command): void { try { $user = $this->repository->find($this->factory->identify(User::class, $command->userId)); } catch (EntityNotFoundException $e) { return; } $this->repository->delete($user); $this->dispatch(UserDeletedEvent::class, [$user]); } } msgphp-0.4.3/src/User/Command/Handler/DeleteUserRoleHandler.php000066400000000000000000000023641327361626700243700ustar00rootroot00000000000000 */ final class DeleteUserRoleHandler { use MessageDispatchingTrait; private $repository; public function __construct(EntityAwareFactoryInterface $factory, DomainMessageBusInterface $bus, UserRoleRepositoryInterface $repository) { $this->factory = $factory; $this->bus = $bus; $this->repository = $repository; } public function __invoke(DeleteUserRoleCommand $command): void { try { $userRole = $this->repository->find($this->factory->identify(User::class, $command->userId), $command->roleName); } catch (EntityNotFoundException $e) { return; } $this->repository->delete($userRole); $this->dispatch(UserRoleDeletedEvent::class, [$userRole]); } } msgphp-0.4.3/src/User/Command/Handler/DisableUserHandler.php000066400000000000000000000027721327361626700237120ustar00rootroot00000000000000 */ final class DisableUserHandler { use EventSourcingCommandHandlerTrait; use MessageDispatchingTrait; private $repository; public function __construct(EntityAwareFactoryInterface $factory, DomainMessageBusInterface $bus, UserRepositoryInterface $repository) { $this->factory = $factory; $this->bus = $bus; $this->repository = $repository; } public function __invoke(DisableUserCommand $command): void { $this->handle($command, function (User $user): void { $this->repository->save($user); $this->dispatch(UserDisabledEvent::class, [$user]); }); } protected function getDomainEvent(DisableUserCommand $command): DisableEvent { return $this->factory->create(DisableEvent::class); } protected function getDomainEventHandler(DisableUserCommand $command): User { return $this->repository->find($this->factory->identify(User::class, $command->userId)); } } msgphp-0.4.3/src/User/Command/Handler/EnableUserHandler.php000066400000000000000000000027601327361626700235320ustar00rootroot00000000000000 */ final class EnableUserHandler { use EventSourcingCommandHandlerTrait; use MessageDispatchingTrait; private $repository; public function __construct(EntityAwareFactoryInterface $factory, DomainMessageBusInterface $bus, UserRepositoryInterface $repository) { $this->factory = $factory; $this->bus = $bus; $this->repository = $repository; } public function __invoke(EnableUserCommand $command): void { $this->handle($command, function (User $user): void { $this->repository->save($user); $this->dispatch(UserEnabledEvent::class, [$user]); }); } protected function getDomainEvent(EnableUserCommand $command): EnableEvent { return $this->factory->create(EnableEvent::class); } protected function getDomainEventHandler(EnableUserCommand $command): User { return $this->repository->find($this->factory->identify(User::class, $command->userId)); } } msgphp-0.4.3/src/User/Command/Handler/RequestUserPasswordHandler.php000066400000000000000000000031441327361626700255140ustar00rootroot00000000000000 */ final class RequestUserPasswordHandler { use EventSourcingCommandHandlerTrait; use MessageDispatchingTrait; private $repository; public function __construct(EntityAwareFactoryInterface $factory, DomainMessageBusInterface $bus, UserRepositoryInterface $repository) { $this->factory = $factory; $this->bus = $bus; $this->repository = $repository; } public function __invoke(RequestUserPasswordCommand $command): void { $this->handle($command, function (User $user): void { $this->repository->save($user); $this->dispatch(UserPasswordRequestedEvent::class, [$user]); }); } protected function getDomainEvent(RequestUserPasswordCommand $command): RequestPasswordEvent { return $this->factory->create(RequestPasswordEvent::class, [$command->token]); } protected function getDomainEventHandler(RequestUserPasswordCommand $command): User { return $this->repository->find($this->factory->identify(User::class, $command->userId)); } } msgphp-0.4.3/src/User/Command/RequestUserPasswordCommand.php000066400000000000000000000005361327361626700241420ustar00rootroot00000000000000 */ class RequestUserPasswordCommand { public $userId; public $token; final public function __construct($userId, string $token = null) { $this->userId = $userId; $this->token = $token; } } msgphp-0.4.3/src/User/CredentialInterface.php000066400000000000000000000003751327361626700211470ustar00rootroot00000000000000 */ interface CredentialInterface { public static function getUsernameField(): string; public function getUsername(): string; } msgphp-0.4.3/src/User/Entity/000077500000000000000000000000001327361626700160125ustar00rootroot00000000000000msgphp-0.4.3/src/User/Entity/Credential/000077500000000000000000000000001327361626700200645ustar00rootroot00000000000000msgphp-0.4.3/src/User/Entity/Credential/Anonymous.php000066400000000000000000000010061327361626700225620ustar00rootroot00000000000000 */ final class Anonymous implements CredentialInterface { public static function getUsernameField(): string { throw new \LogicException('An anonymous credential has no username field.'); } public function getUsername(): string { throw new \LogicException('An anonymous credential has no username.'); } } msgphp-0.4.3/src/User/Entity/Credential/Email.php000066400000000000000000000007661327361626700216350ustar00rootroot00000000000000 */ final class Email implements CredentialInterface { use EmailAsUsername; public function __construct(string $email) { $this->email = $email; } public function withEmail(string $email): self { return new self($email); } } msgphp-0.4.3/src/User/Entity/Credential/EmailPassword.php000066400000000000000000000014771327361626700233600ustar00rootroot00000000000000 */ final class EmailPassword implements CredentialInterface, PasswordProtectedInterface { use EmailAsUsername; use PasswordProtected; public function __construct(string $email, string $password) { $this->email = $email; $this->password = $password; } public function withEmail(string $email): self { return new self($email, $this->password); } public function withPassword(string $password): self { return new self($this->email, $password); } } msgphp-0.4.3/src/User/Entity/Credential/EmailSaltedPassword.php000066400000000000000000000024151327361626700245060ustar00rootroot00000000000000 */ final class EmailSaltedPassword implements CredentialInterface, PasswordProtectedInterface { use EmailAsUsername; use PasswordWithSaltProtected; public function __construct(string $email, string $password, string $passwordSalt) { $this->email = $email; $this->password = $password; $this->passwordSalt = $passwordSalt; } public function withEmail(string $email): self { return new self($email, $this->password, $this->passwordSalt); } public function withPassword(string $password): self { return new self($this->email, $password, $this->passwordSalt); } public function withPasswordSalt(string $passwordSalt): self { return new self($this->email, $this->password, $passwordSalt); } } msgphp-0.4.3/src/User/Entity/Credential/Features/000077500000000000000000000000001327361626700216425ustar00rootroot00000000000000msgphp-0.4.3/src/User/Entity/Credential/Features/EmailAsUsername.php000066400000000000000000000010261327361626700253650ustar00rootroot00000000000000 */ trait EmailAsUsername { /** @var string */ private $email; public static function getUsernameField(): string { return 'email'; } public function getUsername(): string { return $this->email; } public function getEmail(): string { return $this->email; } abstract public function withEmail(string $email): self; } msgphp-0.4.3/src/User/Entity/Credential/Features/NicknameAsUsername.php000066400000000000000000000010561327361626700260660ustar00rootroot00000000000000 */ trait NicknameAsUsername { /** @var string */ private $nickname; public static function getUsernameField(): string { return 'nickname'; } public function getUsername(): string { return $this->nickname; } public function getNickname(): string { return $this->nickname; } abstract public function withNickname(string $nickname): self; } msgphp-0.4.3/src/User/Entity/Credential/Features/PasswordProtected.php000066400000000000000000000010341327361626700260250ustar00rootroot00000000000000 */ trait PasswordProtected { /** @var string */ private $password; public function getPassword(): string { return $this->password; } public function getPasswordAlgorithm(): PasswordAlgorithm { return PasswordAlgorithm::create(); } abstract public function withPassword(string $password): self; } msgphp-0.4.3/src/User/Entity/Credential/Features/PasswordWithSaltProtected.php000066400000000000000000000012251327361626700275070ustar00rootroot00000000000000 */ trait PasswordWithSaltProtected { use PasswordProtected; /** @var string */ private $passwordSalt; public function getPasswordSalt(): string { return $this->passwordSalt; } public function getPasswordAlgorithm(): PasswordAlgorithm { return PasswordAlgorithm::createLegacySalted(new PasswordSalt($this->passwordSalt)); } abstract public function withPasswordSalt(string $passwordSalt): self; } msgphp-0.4.3/src/User/Entity/Credential/Nickname.php000066400000000000000000000010211327361626700223140ustar00rootroot00000000000000 */ final class Nickname implements CredentialInterface { use NicknameAsUsername; public function __construct(string $nickname) { $this->nickname = $nickname; } public function withNickname(string $nickname): self { return new self($nickname); } } msgphp-0.4.3/src/User/Entity/Credential/NicknamePassword.php000066400000000000000000000015351327361626700240510ustar00rootroot00000000000000 */ final class NicknamePassword implements CredentialInterface, PasswordProtectedInterface { use NicknameAsUsername; use PasswordProtected; public function __construct(string $nickname, string $password) { $this->nickname = $nickname; $this->password = $password; } public function withNickname(string $nickname): self { return new self($nickname, $this->password); } public function withPassword(string $password): self { return new self($this->nickname, $password); } } msgphp-0.4.3/src/User/Entity/Credential/NicknameSaltedPassword.php000066400000000000000000000024611327361626700252050ustar00rootroot00000000000000 */ final class NicknameSaltedPassword implements CredentialInterface, PasswordProtectedInterface { use NicknameAsUsername; use PasswordWithSaltProtected; public function __construct(string $nickname, string $password, string $passwordSalt) { $this->nickname = $nickname; $this->password = $password; $this->passwordSalt = $passwordSalt; } public function withNickname(string $nickname): self { return new self($nickname, $this->password, $this->passwordSalt); } public function withPassword(string $password): self { return new self($this->nickname, $password, $this->passwordSalt); } public function withPasswordSalt(string $passwordSalt): self { return new self($this->nickname, $this->password, $passwordSalt); } } msgphp-0.4.3/src/User/Entity/Credential/Token.php000066400000000000000000000013141327361626700216540ustar00rootroot00000000000000 */ final class Token implements CredentialInterface { /** @var string */ private $token; public static function getUsernameField(): string { return 'token'; } public function __construct(string $token) { $this->token = $token; } public function getUsername(): string { return $this->token; } public function getToken(): string { return $this->token; } public function withToken(string $token): self { return new self($token); } } msgphp-0.4.3/src/User/Entity/Features/000077500000000000000000000000001327361626700175705ustar00rootroot00000000000000msgphp-0.4.3/src/User/Entity/Features/AbstractCredential.php000066400000000000000000000035221327361626700240410ustar00rootroot00000000000000 * * @internal */ trait AbstractCredential { /** @var CredentialInterface */ private $credential; public function getCredential(): CredentialInterface { return $this->credential; } private function handleChangeCredentialEvent(ChangeCredentialEvent $event): bool { $handled = false; foreach ($event->fields as $field => $value) { $readIsProp = $writeIsProp = false; if (!method_exists($this, $writeMethod = 'change'.($ucField = ucfirst($field))) && !method_exists($this, $writeMethod = 'set'.$ucField) && !($writeIsProp = property_exists($this, $field))) { throw new \LogicException(sprintf('Unable to handle event "%s", method "%s::change/set%s()" nor property "$%s" does not exists.', get_class($event), get_class($this), $ucField, $field)); } if (!method_exists($this, $readMethod = 'get'.$ucField) && !method_exists($this, $readMethod = 'is'.$ucField) && !method_exists($this, $readMethod = 'has'.$ucField) && !($readIsProp = property_exists($this, $field))) { throw new \LogicException(sprintf('Unable to handle event "%s", method "%s::get/is/has%s()" nor property "$%s" does not exists.', get_class($event), get_class($this), $ucField, $field)); } if ($value !== ($readIsProp ? $this->$field : $this->$readMethod())) { if ($writeIsProp) { $this->$field = $value; } else { $this->$writeMethod($value); } $handled = true; } } return $handled; } } msgphp-0.4.3/src/User/Entity/Features/AbstractPasswordCredential.php000066400000000000000000000011141327361626700255570ustar00rootroot00000000000000 * * @internal */ trait AbstractPasswordCredential { use AbstractCredential; /** @var PasswordProtected */ private $credential; public function getPassword(): string { return $this->credential->getPassword(); } public function changePassword(string $password): void { $this->credential = $this->credential->withPassword($password); } } msgphp-0.4.3/src/User/Entity/Features/AbstractSaltedPasswordCredential.php000066400000000000000000000012021327361626700267120ustar00rootroot00000000000000 * * @internal */ trait AbstractSaltedPasswordCredential { use AbstractPasswordCredential; /** @var PasswordWithSaltProtected */ private $credential; public function getPasswordSalt(): string { return $this->credential->getPasswordSalt(); } public function changePasswordSalt(string $passwordSalt): void { $this->credential = $this->credential->withPasswordSalt($passwordSalt); } } msgphp-0.4.3/src/User/Entity/Features/EmailCredential.php000066400000000000000000000011301327361626700233160ustar00rootroot00000000000000 */ trait EmailCredential { use AbstractCredential; /** @var Email */ private $credential; public function getCredential(): Email { return $this->credential; } public function getEmail(): string { return $this->credential->getEmail(); } public function changeEmail(string $email): void { $this->credential = $this->credential->withEmail($email); } } msgphp-0.4.3/src/User/Entity/Features/EmailPasswordCredential.php000066400000000000000000000010251327361626700250440ustar00rootroot00000000000000 */ trait EmailPasswordCredential { use AbstractPasswordCredential; use EmailCredential { EmailCredential::handleChangeCredentialEvent insteadof AbstractPasswordCredential; } /** @var EmailPassword */ private $credential; public function getCredential(): EmailPassword { return $this->credential; } } msgphp-0.4.3/src/User/Entity/Features/EmailSaltedPasswordCredential.php000066400000000000000000000010711327361626700262020ustar00rootroot00000000000000 */ trait EmailSaltedPasswordCredential { use AbstractSaltedPasswordCredential; use EmailCredential { EmailCredential::handleChangeCredentialEvent insteadof AbstractSaltedPasswordCredential; } /** @var EmailSaltedPassword */ private $credential; public function getCredential(): EmailSaltedPassword { return $this->credential; } } msgphp-0.4.3/src/User/Entity/Features/NicknameCredential.php000066400000000000000000000011661327361626700240250ustar00rootroot00000000000000 */ trait NicknameCredential { use AbstractCredential; /** @var Nickname */ private $credential; public function getCredential(): Nickname { return $this->credential; } public function getNickname(): string { return $this->credential->getNickname(); } public function changeNickname(string $nickname): void { $this->credential = $this->credential->withNickname($nickname); } } msgphp-0.4.3/src/User/Entity/Features/NicknamePasswordCredential.php000066400000000000000000000010471327361626700255460ustar00rootroot00000000000000 */ trait NicknamePasswordCredential { use AbstractPasswordCredential; use NicknameCredential { NicknameCredential::handleChangeCredentialEvent insteadof AbstractPasswordCredential; } /** @var NicknamePassword */ private $credential; public function getCredential(): NicknamePassword { return $this->credential; } } msgphp-0.4.3/src/User/Entity/Features/NicknameSaltedPasswordCredential.php000066400000000000000000000011131327361626700266750ustar00rootroot00000000000000 */ trait NicknameSaltedPasswordCredential { use AbstractSaltedPasswordCredential; use NicknameCredential { NicknameCredential::handleChangeCredentialEvent insteadof AbstractSaltedPasswordCredential; } /** @var NicknameSaltedPassword */ private $credential; public function getCredential(): NicknameSaltedPassword { return $this->credential; } } msgphp-0.4.3/src/User/Entity/Features/ResettablePassword.php000066400000000000000000000023221327361626700241150ustar00rootroot00000000000000 */ trait ResettablePassword { /** @var string|null */ private $passwordResetToken; /** @var \DateTimeInterface|null */ private $passwordRequestedAt; public function getPasswordResetToken(): ?string { return $this->passwordResetToken; } public function getPasswordRequestedAt(): ?\DateTimeInterface { return $this->passwordRequestedAt; } public function requestPassword(string $token = null): void { $this->passwordResetToken = $token ?? bin2hex(random_bytes(32)); $this->passwordRequestedAt = new \DateTimeImmutable(); } public function clearPasswordRequest(): void { $this->passwordResetToken = null; $this->passwordRequestedAt = null; } private function handleRequestPasswordEvent(RequestPasswordEvent $event): bool { if (null === $event->token || $event->token !== $this->passwordResetToken) { $this->requestPassword($event->token); return true; } return false; } } msgphp-0.4.3/src/User/Entity/Features/TokenCredential.php000066400000000000000000000011301327361626700233470ustar00rootroot00000000000000 */ trait TokenCredential { use AbstractCredential; /** @var Token */ private $credential; public function getCredential(): Token { return $this->credential; } public function getToken(): string { return $this->credential->getToken(); } public function changeToken(string $token): void { $this->credential = $this->credential->withToken($token); } } msgphp-0.4.3/src/User/Entity/Fields/000077500000000000000000000000001327361626700172205ustar00rootroot00000000000000msgphp-0.4.3/src/User/Entity/Fields/AttributeValuesField.php000066400000000000000000000013771327361626700240300ustar00rootroot00000000000000 */ trait AttributeValuesField { use AttributesField; /** @var UserAttributeValue[] */ private $attributeValues = []; /** * @return DomainCollectionInterface|UserAttributeValue[] */ public function getAttributeValues(): DomainCollectionInterface { return $this->attributeValues instanceof DomainCollectionInterface ? $this->attributeValues : DomainCollectionFactory::create($this->attributeValues); } } msgphp-0.4.3/src/User/Entity/Fields/EmailsField.php000066400000000000000000000011461327361626700221110ustar00rootroot00000000000000 */ trait EmailsField { /** @var UserEmail[] */ private $emails = []; /** * @return DomainCollectionInterface|UserEmail[] */ public function getEmails(): DomainCollectionInterface { return $this->emails instanceof DomainCollectionInterface ? $this->emails : DomainCollectionFactory::create($this->emails); } } msgphp-0.4.3/src/User/Entity/Fields/RoleField.php000066400000000000000000000006131327361626700215760ustar00rootroot00000000000000 */ trait RoleField { /** @var Role */ private $role; public function getRole(): Role { return $this->role; } public function getRoleName(): string { return $this->role->getName(); } } msgphp-0.4.3/src/User/Entity/Fields/RolesField.php000066400000000000000000000011301327361626700217540ustar00rootroot00000000000000 */ trait RolesField { /** @var UserRole[] */ private $roles; /** * @return DomainCollectionInterface|UserRole[] */ public function getRoles(): DomainCollectionInterface { return $this->roles instanceof DomainCollectionInterface ? $this->roles : DomainCollectionFactory::create($this->roles); } } msgphp-0.4.3/src/User/Entity/Fields/UserField.php000066400000000000000000000006611327361626700216160ustar00rootroot00000000000000 */ trait UserField { /** @var User */ private $user; public function getUser(): User { return $this->user; } public function getUserId(): UserIdInterface { return $this->user->getId(); } } msgphp-0.4.3/src/User/Entity/Role.php000066400000000000000000000003071327361626700174240ustar00rootroot00000000000000 */ abstract class Role { abstract public function getName(): string; } msgphp-0.4.3/src/User/Entity/User.php000066400000000000000000000006701327361626700174440ustar00rootroot00000000000000 */ abstract class User { abstract public function getId(): UserIdInterface; /** * @return CredentialInterface */ public function getCredential() { return new Anonymous(); } } msgphp-0.4.3/src/User/Entity/UserAttributeValue.php000066400000000000000000000010021327361626700223130ustar00rootroot00000000000000 */ abstract class UserAttributeValue { use UserField; use EntityAttributeValue; public function __construct(User $user, AttributeValue $attributeValue) { $this->user = $user; $this->attributeValue = $attributeValue; } } msgphp-0.4.3/src/User/Entity/UserEmail.php000066400000000000000000000007031327361626700204110ustar00rootroot00000000000000 */ abstract class UserEmail { use UserField; private $email; public function __construct(User $user, string $email) { $this->user = $user; $this->email = $email; } public function getEmail(): string { return $this->email; } } msgphp-0.4.3/src/User/Entity/UserRole.php000066400000000000000000000005671327361626700202730ustar00rootroot00000000000000 */ abstract class UserRole { use UserField; use RoleField; public function __construct(User $user, Role $role) { $this->user = $user; $this->role = $role; } } msgphp-0.4.3/src/User/Entity/Username.php000066400000000000000000000007271327361626700203100ustar00rootroot00000000000000 * * @final */ class Username { use UserField; private $username; public function __construct(User $user, string $username) { $this->user = $user; $this->username = $username; } public function __toString(): string { return $this->username; } } msgphp-0.4.3/src/User/Event/000077500000000000000000000000001327361626700156175ustar00rootroot00000000000000msgphp-0.4.3/src/User/Event/Domain/000077500000000000000000000000001327361626700170265ustar00rootroot00000000000000msgphp-0.4.3/src/User/Event/Domain/ChangeCredentialEvent.php000066400000000000000000000005531327361626700237240ustar00rootroot00000000000000 */ class ChangeCredentialEvent implements DomainEventInterface { public $fields; final public function __construct(array $fields) { $this->fields = $fields; } } msgphp-0.4.3/src/User/Event/Domain/RequestPasswordEvent.php000066400000000000000000000005561327361626700237220ustar00rootroot00000000000000 */ class RequestPasswordEvent implements DomainEventInterface { public $token; final public function __construct(string $token = null) { $this->token = $token; } } msgphp-0.4.3/src/User/Event/UserAttributeValueAddedEvent.php000066400000000000000000000006051327361626700240540ustar00rootroot00000000000000 */ class UserAttributeValueAddedEvent { public $userAttributeValue; final public function __construct(UserAttributeValue $userAttributeValue) { $this->userAttributeValue = $userAttributeValue; } } msgphp-0.4.3/src/User/Event/UserAttributeValueChangedEvent.php000066400000000000000000000010231327361626700243770ustar00rootroot00000000000000 */ class UserAttributeValueChangedEvent { public $userAttributeValue; public $oldValue; public $newValue; final public function __construct(UserAttributeValue $userAttributeValue, $oldValue, $newValue) { $this->userAttributeValue = $userAttributeValue; $this->oldValue = $oldValue; $this->newValue = $newValue; } } msgphp-0.4.3/src/User/Event/UserAttributeValueDeletedEvent.php000066400000000000000000000006071327361626700244230ustar00rootroot00000000000000 */ class UserAttributeValueDeletedEvent { public $userAttributeValue; final public function __construct(UserAttributeValue $userAttributeValue) { $this->userAttributeValue = $userAttributeValue; } } msgphp-0.4.3/src/User/Event/UserConfirmedEvent.php000066400000000000000000000004471327361626700221040ustar00rootroot00000000000000 */ class UserConfirmedEvent { public $user; final public function __construct(User $user) { $this->user = $user; } } msgphp-0.4.3/src/User/Event/UserCreatedEvent.php000066400000000000000000000004451327361626700215430ustar00rootroot00000000000000 */ class UserCreatedEvent { public $user; final public function __construct(User $user) { $this->user = $user; } } msgphp-0.4.3/src/User/Event/UserCredentialChangedEvent.php000066400000000000000000000010601327361626700235120ustar00rootroot00000000000000 */ class UserCredentialChangedEvent { public $user; public $oldCredential; public $newCredential; final public function __construct(User $user, CredentialInterface $oldCredential, CredentialInterface $newCredential) { $this->user = $user; $this->oldCredential = $oldCredential; $this->newCredential = $newCredential; } } msgphp-0.4.3/src/User/Event/UserDeletedEvent.php000066400000000000000000000004451327361626700215420ustar00rootroot00000000000000 */ class UserDeletedEvent { public $user; final public function __construct(User $user) { $this->user = $user; } } msgphp-0.4.3/src/User/Event/UserDisabledEvent.php000066400000000000000000000004461327361626700217040ustar00rootroot00000000000000 */ class UserDisabledEvent { public $user; final public function __construct(User $user) { $this->user = $user; } } msgphp-0.4.3/src/User/Event/UserEmailAddedEvent.php000066400000000000000000000005061327361626700221430ustar00rootroot00000000000000 */ class UserEmailAddedEvent { public $userEmail; final public function __construct(UserEmail $userEmail) { $this->userEmail = $userEmail; } } msgphp-0.4.3/src/User/Event/UserEmailConfirmedEvent.php000066400000000000000000000005121327361626700230450ustar00rootroot00000000000000 */ class UserEmailConfirmedEvent { public $userEmail; final public function __construct(UserEmail $userEmail) { $this->userEmail = $userEmail; } } msgphp-0.4.3/src/User/Event/UserEmailDeletedEvent.php000066400000000000000000000005101327361626700225030ustar00rootroot00000000000000 */ class UserEmailDeletedEvent { public $userEmail; final public function __construct(UserEmail $userEmail) { $this->userEmail = $userEmail; } } msgphp-0.4.3/src/User/Event/UserEnabledEvent.php000066400000000000000000000004451327361626700215260ustar00rootroot00000000000000 */ class UserEnabledEvent { public $user; final public function __construct(User $user) { $this->user = $user; } } msgphp-0.4.3/src/User/Event/UserPasswordRequestedEvent.php000066400000000000000000000004571327361626700236630ustar00rootroot00000000000000 */ class UserPasswordRequestedEvent { public $user; final public function __construct(User $user) { $this->user = $user; } } msgphp-0.4.3/src/User/Event/UserRoleAddedEvent.php000066400000000000000000000004771327361626700220240ustar00rootroot00000000000000 */ class UserRoleAddedEvent { public $userRole; final public function __construct(UserRole $userRole) { $this->userRole = $userRole; } } msgphp-0.4.3/src/User/Event/UserRoleDeletedEvent.php000066400000000000000000000005011327361626700223550ustar00rootroot00000000000000 */ class UserRoleDeletedEvent { public $userRole; final public function __construct(UserRole $userRole) { $this->userRole = $userRole; } } msgphp-0.4.3/src/User/Infra/000077500000000000000000000000001327361626700155755ustar00rootroot00000000000000msgphp-0.4.3/src/User/Infra/Console/000077500000000000000000000000001327361626700171775ustar00rootroot00000000000000msgphp-0.4.3/src/User/Infra/Console/Command/000077500000000000000000000000001327361626700205555ustar00rootroot00000000000000msgphp-0.4.3/src/User/Infra/Console/Command/AddUserRoleCommand.php000066400000000000000000000043251327361626700247420ustar00rootroot00000000000000 */ final class AddUserRoleCommand extends UserRoleCommand { protected static $defaultName = 'user:role:add'; /** @var StyleInterface */ private $io; private $contextFactory; public function __construct(EntityAwareFactoryInterface $factory, DomainMessageBusInterface $bus, UserRepositoryInterface $userRepository, RoleRepositoryInterface $roleRepository, ContextFactoryInterface $contextFactory) { $this->contextFactory = $contextFactory; parent::__construct($factory, $bus, $userRepository, $roleRepository); } public function onMessageReceived($message): void { if ($message instanceof UserRoleAddedEvent) { $this->io->success(sprintf('Added role "%s" to user %s', $message->userRole->getRoleName(), $message->userRole->getUser()->getCredential()->getUsername())); } } protected function configure(): void { parent::configure(); $this->setDescription('Add a user role'); $this->contextFactory->configure($this->getDefinition()); } protected function execute(InputInterface $input, OutputInterface $output): int { $this->io = new SymfonyStyle($input, $output); $user = $this->getUser($input, $this->io); $role = $this->getRole($input, $this->io); $context = $this->contextFactory->getContext($input, $this->io, ['user' => $user, 'role' => $role]); $this->dispatch(AddUserRoleDomainCommand::class, [$user->getId(), $role->getName(), $context]); return 0; } } msgphp-0.4.3/src/User/Infra/Console/Command/ChangeUserCredentialCommand.php000066400000000000000000000062731327361626700266140ustar00rootroot00000000000000 */ final class ChangeUserCredentialCommand extends UserCommand { protected static $defaultName = 'user:change-credential'; /** @var StyleInterface */ private $io; private $contextFactory; private $fields = []; public function __construct(EntityAwareFactoryInterface $factory, DomainMessageBusInterface $bus, UserRepositoryInterface $repository, ContextFactoryInterface $contextFactory) { $this->contextFactory = $contextFactory; parent::__construct($factory, $bus, $repository); } public function onMessageReceived($message): void { if ($message instanceof UserCredentialChangedEvent) { $this->io->success('Changed user credential for '.$message->user->getCredential()->getUsername()); $rows = []; foreach (array_diff((array) $message->newCredential, $oldValues = (array) $message->oldCredential) as $key => $value) { $field = false === ($i = strrpos($key, "\00")) ? $key : substr($key, $i + 1); // @todo use VarDumper $rows[] = [$field, json_encode($oldValues[$key] ?? null), json_encode($value)]; } if ($rows) { $this->io->table(['Field', 'Old Value', 'New Value'], $rows); } } } protected function configure(): void { parent::configure(); $this->setDescription('Change a user credential'); $definition = $this->getDefinition(); $currentFields = array_keys($definition->getOptions() + $definition->getArguments()); $this->contextFactory->configure($this->getDefinition()); $this->fields = array_values(array_diff(array_keys($definition->getOptions() + $definition->getArguments()), $currentFields)); } protected function execute(InputInterface $input, OutputInterface $output): int { $this->io = new SymfonyStyle($input, $output); $user = $this->getUser($input, $this->io); $context = $this->contextFactory->getContext($input, $this->io); if (!$context) { $field = $this->io->choice('Select a field to change', $this->fields); return $this->run(new ArrayInput([ '--'.$field => null, '--by-id' => true, 'user' => $user->getId()->toString(), ]), $output); } $this->dispatch(ChangeUserCredentialDomainCommand::class, [$user->getId(), $context]); return 0; } } msgphp-0.4.3/src/User/Infra/Console/Command/ConfirmUserCommand.php000066400000000000000000000024021327361626700250170ustar00rootroot00000000000000 */ final class ConfirmUserCommand extends UserCommand { protected static $defaultName = 'user:confirm'; /** @var StyleInterface */ private $io; public function onMessageReceived($message): void { if ($message instanceof UserConfirmedEvent) { $this->io->success('Confirmed user '.$message->user->getCredential()->getUsername()); } } protected function configure(): void { parent::configure(); $this->setDescription('Confirm a user'); } protected function execute(InputInterface $input, OutputInterface $output): int { $this->io = new SymfonyStyle($input, $output); $user = $this->getUser($input, $this->io); $this->dispatch(ConfirmUserDomainCommand::class, [$user->getId()]); return 0; } } msgphp-0.4.3/src/User/Infra/Console/Command/CreateUserCommand.php000066400000000000000000000037531327361626700246370ustar00rootroot00000000000000 */ final class CreateUserCommand extends Command implements MessageReceivingInterface { use MessageDispatchingTrait; protected static $defaultName = 'user:create'; private $contextFactory; /** @var StyleInterface */ private $io; public function __construct(DomainObjectFactoryInterface $factory, DomainMessageBusInterface $bus, ContextFactoryInterface $contextFactory) { $this->factory = $factory; $this->bus = $bus; $this->contextFactory = $contextFactory; parent::__construct(); } /** * @internal */ public function onMessageReceived($message): void { if ($message instanceof UserCreatedEvent) { $this->io->success('Created user '.$message->user->getCredential()->getUsername()); } } protected function configure(): void { $this->setDescription('Create a user'); $this->contextFactory->configure($this->getDefinition()); } protected function execute(InputInterface $input, OutputInterface $output): int { $this->io = new SymfonyStyle($input, $output); $context = $this->contextFactory->getContext($input, $this->io); $this->dispatch(CreateUserDomainCommand::class, [$context]); return 0; } } msgphp-0.4.3/src/User/Infra/Console/Command/DeleteUserCommand.php000066400000000000000000000027361327361626700246360ustar00rootroot00000000000000 */ final class DeleteUserCommand extends UserCommand { protected static $defaultName = 'user:delete'; /** @var StyleInterface */ private $io; public function onMessageReceived($message): void { if ($message instanceof UserDeletedEvent) { $this->io->success('Deleted user '.$message->user->getCredential()->getUsername()); } } protected function configure(): void { parent::configure(); $this->setDescription('Delete a user'); } protected function execute(InputInterface $input, OutputInterface $output): int { $this->io = new SymfonyStyle($input, $output); $user = $this->getUser($input, $this->io); if ($input->isInteractive()) { $this->io->note('Deleting user '.$user->getCredential()->getUsername()); if (!$this->io->confirm('Are you sure?')) { return 0; } } $this->dispatch(DeleteUserDomainCommand::class, [$user->getId()]); return 0; } } msgphp-0.4.3/src/User/Infra/Console/Command/DeleteUserRoleCommand.php000066400000000000000000000026561327361626700254610ustar00rootroot00000000000000 */ final class DeleteUserRoleCommand extends UserRoleCommand { protected static $defaultName = 'user:role:delete'; /** @var StyleInterface */ private $io; public function onMessageReceived($message): void { if ($message instanceof UserRoleDeletedEvent) { $this->io->success(sprintf('Deleted role "%s" from user %s', $message->userRole->getRoleName(), $message->userRole->getUser()->getCredential()->getUsername())); } } protected function configure(): void { parent::configure(); $this->setDescription('Delete a user role'); } protected function execute(InputInterface $input, OutputInterface $output): int { $this->io = new SymfonyStyle($input, $output); $user = $this->getUser($input, $this->io); $role = $this->getRole($input, $this->io); $this->dispatch(DeleteUserRoleDomainCommand::class, [$user->getId(), $role->getName()]); return 0; } } msgphp-0.4.3/src/User/Infra/Console/Command/DisableUserCommand.php000066400000000000000000000023771327361626700250000ustar00rootroot00000000000000 */ final class DisableUserCommand extends UserCommand { protected static $defaultName = 'user:disable'; /** @var StyleInterface */ private $io; public function onMessageReceived($message): void { if ($message instanceof UserDisabledEvent) { $this->io->success('Disabled user '.$message->user->getCredential()->getUsername()); } } protected function configure(): void { parent::configure(); $this->setDescription('Disable a user'); } protected function execute(InputInterface $input, OutputInterface $output): int { $this->io = new SymfonyStyle($input, $output); $user = $this->getUser($input, $this->io); $this->dispatch(DisableUserDomainCommand::class, [$user->getId()]); return 0; } } msgphp-0.4.3/src/User/Infra/Console/Command/EnableUserCommand.php000066400000000000000000000023661327361626700246210ustar00rootroot00000000000000 */ final class EnableUserCommand extends UserCommand { protected static $defaultName = 'user:enable'; /** @var StyleInterface */ private $io; public function onMessageReceived($message): void { if ($message instanceof UserEnabledEvent) { $this->io->success('Enabled user '.$message->user->getCredential()->getUsername()); } } protected function configure(): void { parent::configure(); $this->setDescription('Enable a user'); } protected function execute(InputInterface $input, OutputInterface $output): int { $this->io = new SymfonyStyle($input, $output); $user = $this->getUser($input, $this->io); $this->dispatch(EnableUserDomainCommand::class, [$user->getId()]); return 0; } } msgphp-0.4.3/src/User/Infra/Console/Command/SynchronizeUsernamesCommand.php000066400000000000000000000055111327361626700267650ustar00rootroot00000000000000 */ final class SynchronizeUsernamesCommand extends Command { protected static $defaultName = 'user:synchronize:usernames'; private $repository; public function __construct(UsernameRepositoryInterface $repository) { $this->repository = $repository; parent::__construct(); } protected function configure(): void { $this ->setDescription('Synchronize usernames') ->addOption('dry-run', null, InputOption::VALUE_NONE, 'Perform a dry run'); } protected function execute(InputInterface $input, OutputInterface $output): int { $io = new SymfonyStyle($input, $output); $dryRun = $input->getOption('dry-run'); $usernames = $unknownUsernames = $this->repository->findAll(); $rows = []; $added = $deleted = 0; foreach ($this->repository->findAllFromTargets() as $username) { if ($usernames->containsKey($usernameValue = (string) $username)) { $unknownUsernames = $unknownUsernames->filter(function (Username $knownUsername) use ($usernameValue): bool { return $usernameValue !== (string) $knownUsername; }); continue; } if (!$dryRun) { $this->repository->save($username); } $rows[] = sprintf('Added username %s for user %s', $usernameValue, $username->getUser()->getId()->toString()); ++$added; } foreach ($unknownUsernames as $unknownUsername) { if (!$dryRun) { $this->repository->delete($unknownUsername); } $rows[] = sprintf('Deleted username %s from user %s', (string) $unknownUsername, $unknownUsername->getUser()->getId()->toString()); ++$deleted; } if ($rows) { $io->listing($rows); } if ($added || $deleted) { $io->success([ $added.' '.(1 === $added ? 'username' : 'usernames').' added', $deleted.' '.(1 === $deleted ? 'username' : 'usernames').' deleted', ]); } else { $io->success('All usernames are in sync'); } if ($dryRun) { $io->warning('This was a dry run, nothing has changed!'); } return 0; } } msgphp-0.4.3/src/User/Infra/Console/Command/UserCommand.php000066400000000000000000000040451327361626700235060ustar00rootroot00000000000000 */ abstract class UserCommand extends Command implements MessageReceivingInterface { use MessageDispatchingTrait { dispatch as protected; } private $repository; public function __construct(EntityAwareFactoryInterface $factory, DomainMessageBusInterface $bus, UserRepositoryInterface $repository) { $this->factory = $factory; $this->bus = $bus; $this->repository = $repository; parent::__construct(); } /** * @internal */ public function onMessageReceived($message): void { } protected function configure(): void { $this ->addOption('by-id', null, InputOption::VALUE_NONE, 'Find user by identifier') ->addArgument('user', InputArgument::OPTIONAL, 'The username or user ID'); } protected function getUser(InputInterface $input, StyleInterface $io): User { $byId = $input->getOption('by-id'); if (null === $value = $input->getArgument('user')) { if (!$input->isInteractive()) { throw new \LogicException('No value provided for "user".'); } do { $value = $io->ask($byId ? 'Identifier' : 'Username'); } while (null === $value); } return $byId ? $this->repository->find($this->factory->identify(User::class, $value)) : $this->repository->findByUsername($value); } } msgphp-0.4.3/src/User/Infra/Console/Command/UserRoleCommand.php000066400000000000000000000027511327361626700243320ustar00rootroot00000000000000 */ abstract class UserRoleCommand extends UserCommand { private $repository; public function __construct(EntityAwareFactoryInterface $factory, DomainMessageBusInterface $bus, UserRepositoryInterface $userRepository, RoleRepositoryInterface $roleRepository) { parent::__construct($factory, $bus, $userRepository); $this->repository = $roleRepository; } protected function configure(): void { parent::configure(); $this->addArgument('role', InputArgument::OPTIONAL, 'The role name'); } protected function getRole(InputInterface $input, StyleInterface $io): Role { if (null === $value = $input->getArgument('role')) { if (!$input->isInteractive()) { throw new \LogicException('No value provided for "role".'); } do { $value = $io->ask('Role name'); } while (null === $value); } return $this->repository->find($value); } } msgphp-0.4.3/src/User/Infra/Doctrine/000077500000000000000000000000001327361626700173445ustar00rootroot00000000000000msgphp-0.4.3/src/User/Infra/Doctrine/EntityFieldsMapping.php000066400000000000000000000065061327361626700240030ustar00rootroot00000000000000 * * @internal */ final class EntityFieldsMapping implements ObjectFieldMappingProviderInterface { private const CREDENTIALS = [ Features\EmailCredential::class => Credential\Email::class, Features\EmailPasswordCredential::class => Credential\EmailPassword::class, Features\EmailSaltedPasswordCredential::class => Credential\EmailSaltedPassword::class, Features\NicknameCredential::class => Credential\Nickname::class, Features\NicknamePasswordCredential::class => Credential\NicknamePassword::class, Features\NicknameSaltedPasswordCredential::class => Credential\NicknameSaltedPassword::class, Features\TokenCredential::class => Credential\Token::class, ]; public static function getObjectFieldMapping(): array { $credentials = self::CREDENTIALS; array_walk($credentials, function (string &$credential): void { $credential = ['credential' => [ 'type' => self::TYPE_EMBEDDED, 'class' => $credential, 'columnPrefix' => null, ]]; unset($credential); }); return $credentials + [ Features\ResettablePassword::class => [ 'passwordResetToken' => [ 'type' => 'string', 'unique' => true, 'nullable' => true, ], 'passwordRequestedAt' => [ 'type' => 'datetime', 'nullable' => true, ], ], Fields\AttributeValuesField::class => [ 'attributeValues' => [ 'type' => self::TYPE_ONE_TO_MANY, 'targetEntity' => UserAttributeValue::class, 'mappedBy' => 'user', ], ], Fields\EmailsField::class => [ 'emails' => [ 'type' => self::TYPE_ONE_TO_MANY, 'targetEntity' => UserEmail::class, 'mappedBy' => 'user', 'indexBy' => 'email', ], ], Fields\RoleField::class => [ 'role' => [ 'type' => self::TYPE_MANY_TO_ONE, 'targetEntity' => Role::class, 'joinColumns' => [ ['referencedColumnName' => 'name', 'nullable' => false], ], ], ], Fields\RolesField::class => [ 'roles' => [ 'type' => self::TYPE_ONE_TO_MANY, 'targetEntity' => UserRole::class, 'mappedBy' => 'user', ], ], Fields\UserField::class => [ 'user' => [ 'type' => self::TYPE_MANY_TO_ONE, 'targetEntity' => User::class, 'joinColumns' => [ ['nullable' => false], ], ], ], ]; } } msgphp-0.4.3/src/User/Infra/Doctrine/Event/000077500000000000000000000000001327361626700204255ustar00rootroot00000000000000msgphp-0.4.3/src/User/Infra/Doctrine/Event/UsernameListener.php000066400000000000000000000114051327361626700244240ustar00rootroot00000000000000 */ final class UsernameListener { private $mapping; private $updateUsernames = []; public function __construct(array $mapping) { $this->mapping = $mapping; } public function loadClassMetadata(LoadClassMetadataEventArgs $event): void { $metadata = $event->getClassMetadata(); if (!isset($this->mapping[$metadata->getName()])) { return; } try { $metadata->addEntityListener('prePersist', self::class, 'add'); $metadata->addEntityListener('preUpdate', self::class, 'update'); $metadata->addEntityListener('preRemove', self::class, 'remove'); } catch (MappingException $e) { // duplicate } } /** * @param object $entity */ public function add($entity, LifecycleEventArgs $event): void { $em = $event->getEntityManager(); foreach ($this->getUsernames($entity, $em) as $username) { $em->persist($username); } } /** * @param object $entity */ public function update($entity, PreUpdateEventArgs $event): void { $em = $event->getEntityManager(); foreach ($this->getMapping($entity, $event->getEntityManager()) as $field => $mappedBy) { if (!$event->hasChangedField($field)) { continue; } if (null !== $username = $event->getOldValue($field)) { $this->updateUsernames[$username] = $event->getNewValue($field); } elseif (null !== $username = $event->getNewValue($field)) { $user = null === $mappedBy ? $entity : $em->getClassMetadata(get_class($entity))->getFieldValue($entity, $mappedBy); if (null === $user) { continue; } $em->persist(new Username($user, $username)); } } } /** * @param object $entity */ public function remove($entity, LifecycleEventArgs $event): void { $em = $event->getEntityManager(); $metadata = $em->getClassMetadata(get_class($entity)); foreach (array_keys($this->getMapping($entity, $em)) as $field) { if (null === $username = $metadata->getFieldValue($entity, $field)) { continue; } $this->updateUsernames[$username] = null; } } public function postFlush(PostFlushEventArgs $event): void { if (!$this->updateUsernames) { return; } $em = $event->getEntityManager(); $qb = $em->createQueryBuilder(); $qb->select('u'); $qb->from(Username::class, 'u'); $qb->where($qb->expr()->in('u.username', ':usernames')); $qb->setParameter('usernames', array_keys($this->updateUsernames)); foreach ($qb->getQuery()->getResult() as $username) { /* @var Username $username */ $em->remove($username); if (isset($this->updateUsernames[$usernameValue = (string) $username])) { $em->persist(new Username($username->getUser(), $this->updateUsernames[$usernameValue])); } } $this->updateUsernames = []; $em->flush(); } /** * @param object $entity * * @return Username[] */ private function getUsernames($entity, EntityManagerInterface $em): iterable { $metadata = $em->getClassMetadata(get_class($entity)); foreach ($this->getMapping($entity, $em) as $field => $mappedBy) { $user = null === $mappedBy ? $entity : $metadata->getFieldValue($entity, $mappedBy); if (null === $user || null === $username = $metadata->getFieldValue($entity, $field)) { continue; } yield new Username($user, $username); } } private function getMapping($entity, EntityManagerInterface $em): array { if (isset($this->mapping[$class = ClassUtils::getClass($entity)])) { return $this->mapping[$class]; } foreach ($em->getClassMetadata($class)->parentClasses as $parent) { if (isset($this->mapping[$parent])) { return $this->mapping[$parent]; } } throw new \LogicException(sprintf('No username mapping available for entity "%s".', $class)); } } msgphp-0.4.3/src/User/Infra/Doctrine/Repository/000077500000000000000000000000001327361626700215235ustar00rootroot00000000000000msgphp-0.4.3/src/User/Infra/Doctrine/Repository/RoleRepository.php000066400000000000000000000020351327361626700252350ustar00rootroot00000000000000 */ final class RoleRepository implements RoleRepositoryInterface { use DomainEntityRepositoryTrait; private $alias = 'role'; /** * @return DomainCollectionInterface|Role[] */ public function findAll(int $offset = 0, int $limit = 0): DomainCollectionInterface { return $this->doFindAll($offset, $limit); } public function find(string $name): Role { return $this->doFind($name); } public function exists(string $name): bool { return $this->doExists($name); } public function save(Role $role): void { $this->doSave($role); } public function delete(Role $role): void { $this->doDelete($role); } } msgphp-0.4.3/src/User/Infra/Doctrine/Repository/UserAttributeValueRepository.php000066400000000000000000000054761327361626700301470ustar00rootroot00000000000000 */ final class UserAttributeValueRepository implements UserAttributeValueRepositoryInterface { use EntityAttributeValueRepositoryTrait; private $alias = 'user_attribute_value'; private $attributeValueField = 'attributeValue'; /** * @return DomainCollectionInterface|UserAttributeValue[] */ public function findAllByAttributeId(AttributeIdInterface $attributeId, int $offset = 0, int $limit = 0): DomainCollectionInterface { $qb = $this->createQueryBuilder(); $this->addAttributeCriteria($qb, $attributeId); return $this->createResultSet($qb->getQuery(), $offset, $limit); } /** * @return DomainCollectionInterface|UserAttributeValue[] */ public function findAllByAttributeIdAndValue(AttributeIdInterface $attributeId, $value, int $offset = 0, int $limit = 0): DomainCollectionInterface { $qb = $this->createQueryBuilder(); $this->addAttributeCriteria($qb, $attributeId, $value); return $this->createResultSet($qb->getQuery(), $offset, $limit); } /** * @return DomainCollectionInterface|UserAttributeValue[] */ public function findAllByUserId(UserIdInterface $userId, int $offset = 0, int $limit = 0): DomainCollectionInterface { return $this->doFindAllByFields(['user' => $userId], $offset, $limit); } /** * @return DomainCollectionInterface|UserAttributeValue[] */ public function findAllByUserIdAndAttributeId(UserIdInterface $userId, AttributeIdInterface $attributeId, int $offset = 0, int $limit = 0): DomainCollectionInterface { $qb = $this->createQueryBuilder(); $this->addFieldCriteria($qb, ['user' => $userId]); $this->addAttributeCriteria($qb, $attributeId); return $this->createResultSet($qb->getQuery(), $offset, $limit); } public function find(AttributeValueIdInterface $attributeValueId): UserAttributeValue { return $this->doFind($attributeValueId); } public function exists(AttributeValueIdInterface $attributeValueId): bool { return $this->doExists($attributeValueId); } public function save(UserAttributeValue $userAttributeValue): void { $this->doSave($userAttributeValue); } public function delete(UserAttributeValue $userAttributeValue): void { $this->doDelete($userAttributeValue); } } msgphp-0.4.3/src/User/Infra/Doctrine/Repository/UserEmailRepository.php000066400000000000000000000023021327361626700262170ustar00rootroot00000000000000 */ final class UserEmailRepository implements UserEmailRepositoryInterface { use DomainEntityRepositoryTrait; private $alias = 'user_email'; /** * @return DomainCollectionInterface|UserEmail[] */ public function findAllByUserId(UserIdInterface $userId, int $offset = 0, int $limit = 0): DomainCollectionInterface { return $this->doFindAllByFields(['user' => $userId], $offset, $limit); } public function find(string $email): UserEmail { return $this->doFind($email); } public function exists(string $email): bool { return $this->doExists($email); } public function save(UserEmail $userEmail): void { $this->doSave($userEmail); } public function delete(UserEmail $userEmail): void { $this->doDelete($userEmail); } } msgphp-0.4.3/src/User/Infra/Doctrine/Repository/UserRepository.php000066400000000000000000000062661327361626700252640ustar00rootroot00000000000000 */ final class UserRepository implements UserRepositoryInterface { use DomainEntityRepositoryTrait { __construct as private __parent_construct; } private $alias = 'user'; private $usernameField; public function __construct(string $class, EntityManagerInterface $em, string $usernameField = null, DomainIdentityHelper $identityHelper = null) { $this->__parent_construct($class, $em, $identityHelper); $this->usernameField = $usernameField; } /** * @return DomainCollectionInterface|User[] */ public function findAll(int $offset = 0, int $limit = 0): DomainCollectionInterface { return $this->doFindAll($offset, $limit); } public function find(UserIdInterface $id): User { return $this->doFind($id); } public function findByUsername(string $username): User { if (null === $this->usernameField) { throw new \LogicException('Cannot find users by username without a username field name.'); } $qb = $this->createUsernameQueryBuilder($username); $criteria = [$this->usernameField => $username]; if (null === $qb) { return $this->doFindByFields($criteria); } try { return $qb->getQuery()->getSingleResult(); } catch (NoResultException $e) { throw EntityNotFoundException::createForFields($this->class, $criteria); } } public function exists(UserIdInterface $id): bool { return $this->doExists($id); } public function usernameExists(string $username): bool { $qb = $this->createUsernameQueryBuilder($username); if (null === $qb) { return $this->doExistsByFields([$this->usernameField => $username]); } $qb->select('1'); return (bool) $qb->getQuery()->getScalarResult(); } public function save(User $user): void { $this->doSave($user); } public function delete(User $user): void { $this->doDelete($user); } private function createUsernameQueryBuilder(string $username): ?QueryBuilder { if ($this->em->getMetadataFactory()->isTransient(Username::class)) { return null; } $qb = $this->em->createQueryBuilder(); $qb->select('user'); $qb->from($this->class, 'user'); $qb->join(Username::class, 'username', Join::WITH, 'username.user = user'); $qb->where($qb->expr()->eq('username.username', ':username')); $qb->setMaxResults(1); $qb->setParameter('username', $username); return $qb; } } msgphp-0.4.3/src/User/Infra/Doctrine/Repository/UserRoleRepository.php000066400000000000000000000024611327361626700260770ustar00rootroot00000000000000 */ final class UserRoleRepository implements UserRoleRepositoryInterface { use DomainEntityRepositoryTrait; private $alias = 'user_role'; /** * @return DomainCollectionInterface|UserRole[] */ public function findAllByUserId(UserIdInterface $userId, int $offset = 0, int $limit = 0): DomainCollectionInterface { return $this->doFindAllByFields(['user' => $userId], $offset, $limit); } public function find(UserIdInterface $userId, string $roleName): UserRole { return $this->doFind(['user' => $userId, 'role' => $roleName]); } public function exists(UserIdInterface $userId, string $roleName): bool { return $this->doExists(['user' => $userId, 'role' => $roleName]); } public function save(UserRole $userRole): void { $this->doSave($userRole); } public function delete(UserRole $userRole): void { $this->doDelete($userRole); } } msgphp-0.4.3/src/User/Infra/Doctrine/Repository/UsernameRepository.php000066400000000000000000000101701327361626700261120ustar00rootroot00000000000000 */ final class UsernameRepository implements UsernameRepositoryInterface { use DomainEntityRepositoryTrait { __construct as private __parent_construct; } private $alias = 'username'; private $targetMapping; public function __construct(string $class, EntityManagerInterface $em, array $targetMapping = [], DomainIdentityHelper $identityHelper = null) { $this->__parent_construct($class, $em, $identityHelper); $this->targetMapping = $targetMapping; } /** * @return DomainCollectionInterface|Username[] */ public function findAll(int $offset = 0, int $limit = 0): DomainCollectionInterface { $qb = $this->createQueryBuilder(); $qb->indexBy($this->alias, 'username'); return $this->createResultSet($qb->getQuery(), $offset, $limit); } /** * @return DomainCollectionInterface|Username[] */ public function findAllFromTargets(int $offset = 0, int $limit = 0): DomainCollectionInterface { if (!$this->targetMapping) { throw new \LogicException('No username mapping available.'); } $results = $targets = []; foreach ($this->targetMapping as $class => $mappings) { $qb = $this->em->createQueryBuilder(); $metadata = $this->em->getClassMetadata($class); $fields = array_flip($idFields = $metadata->getIdentifierFieldNames()); foreach ($mappings as $field => $mappedBy) { $targets[$class][$field] = $mappedBy; $fields[$field] = true; if (null !== $mappedBy) { $fields[$mappedBy] = true; } } foreach ((array) $metadata->discriminatorMap as $discriminatorClass) { if (isset($targets[$discriminatorClass])) { $targets[$discriminatorClass] += $targets[$class]; } else { $targets[$discriminatorClass] = $targets[$class]; } } $qb->addSelect(sprintf('partial e.{%s}', implode(', ', array_keys($fields)))); $qb->from($class, 'e'); $results[] = $qb->getQuery()->getResult(); } $result = []; foreach ($results ? array_merge(...$results) : [] as $target) { $metadata = $this->em->getClassMetadata($class = ClassUtils::getRealClass(get_class($target))); foreach ($targets[$class] as $field => $mappedBy) { $user = null === $mappedBy ? $target : $metadata->getFieldValue($target, $mappedBy); if (null === $user) { continue; } if (!$user instanceof User) { throw new \LogicException(sprintf('Field "%s.%s" must return an instance of "%s" or null, got "%s".', $class, $field, get_class($target), is_object($user) ? get_class($user) : gettype($user))); } if (null !== $username = $metadata->getFieldValue($target, $field)) { $result[] = new $this->class($user, $username); } } } $result = DomainCollectionFactory::create($result); return $offset || $limit ? $result->slice($offset, $limit) : $result; } public function find(string $username): Username { return $this->doFind($username); } public function exists(string $username): bool { return $this->doExists($username); } public function save(Username $user): void { $this->doSave($user); } public function delete(Username $user): void { $this->doDelete($user); } } msgphp-0.4.3/src/User/Infra/Doctrine/Resources/000077500000000000000000000000001327361626700213165ustar00rootroot00000000000000msgphp-0.4.3/src/User/Infra/Doctrine/Resources/dist-mapping/000077500000000000000000000000001327361626700237125ustar00rootroot00000000000000msgphp-0.4.3/src/User/Infra/Doctrine/Resources/dist-mapping/User.Entity.Credential.Email.orm.xml000066400000000000000000000007251327361626700325240ustar00rootroot00000000000000 User.Entity.Credential.EmailPassword.orm.xml000066400000000000000000000007771327361626700341770ustar00rootroot00000000000000msgphp-0.4.3/src/User/Infra/Doctrine/Resources/dist-mapping User.Entity.Credential.EmailSaltedPassword.orm.xml000066400000000000000000000010531327361626700353200ustar00rootroot00000000000000msgphp-0.4.3/src/User/Infra/Doctrine/Resources/dist-mapping msgphp-0.4.3/src/User/Infra/Doctrine/Resources/dist-mapping/User.Entity.Credential.Nickname.orm.xml000066400000000000000000000007331327361626700332210ustar00rootroot00000000000000 User.Entity.Credential.NicknamePassword.orm.xml000066400000000000000000000010051327361626700346560ustar00rootroot00000000000000msgphp-0.4.3/src/User/Infra/Doctrine/Resources/dist-mapping User.Entity.Credential.NicknameSaltedPassword.orm.xml000066400000000000000000000010611327361626700360150ustar00rootroot00000000000000msgphp-0.4.3/src/User/Infra/Doctrine/Resources/dist-mapping msgphp-0.4.3/src/User/Infra/Doctrine/Resources/dist-mapping/User.Entity.Credential.Token.orm.xml000066400000000000000000000007251327361626700325550ustar00rootroot00000000000000 msgphp-0.4.3/src/User/Infra/Doctrine/Resources/dist-mapping/User.Entity.Role.orm.xml000066400000000000000000000006231327361626700303220ustar00rootroot00000000000000 msgphp-0.4.3/src/User/Infra/Doctrine/Resources/dist-mapping/User.Entity.User.orm.xml000066400000000000000000000006231327361626700303370ustar00rootroot00000000000000 msgphp-0.4.3/src/User/Infra/Doctrine/Resources/dist-mapping/User.Entity.UserAttributeValue.orm.xml000066400000000000000000000015531327361626700332230ustar00rootroot00000000000000 msgphp-0.4.3/src/User/Infra/Doctrine/Resources/dist-mapping/User.Entity.UserEmail.orm.xml000066400000000000000000000011571327361626700313120ustar00rootroot00000000000000 msgphp-0.4.3/src/User/Infra/Doctrine/Resources/dist-mapping/User.Entity.UserRole.orm.xml000066400000000000000000000015461327361626700311660ustar00rootroot00000000000000 msgphp-0.4.3/src/User/Infra/Doctrine/Resources/dist-mapping/User.Entity.Username.orm.xml000066400000000000000000000011511327361626700311750ustar00rootroot00000000000000 msgphp-0.4.3/src/User/Infra/Doctrine/Type/000077500000000000000000000000001327361626700202655ustar00rootroot00000000000000msgphp-0.4.3/src/User/Infra/Doctrine/Type/UserIdType.php000066400000000000000000000004261327361626700230350ustar00rootroot00000000000000 */ final class UserIdType extends DomainIdType { public const NAME = 'msgphp_user_id'; } msgphp-0.4.3/src/User/Infra/Form/000077500000000000000000000000001327361626700165005ustar00rootroot00000000000000msgphp-0.4.3/src/User/Infra/Form/Type/000077500000000000000000000000001327361626700174215ustar00rootroot00000000000000msgphp-0.4.3/src/User/Infra/Form/Type/HashedPasswordType.php000066400000000000000000000145231327361626700237200ustar00rootroot00000000000000 */ final class HashedPasswordType extends AbstractType { private $passwordHashing; private $tokenStorage; public function __construct(PasswordHashingInterface $passwordHashing, TokenStorageInterface $tokenStorage = null) { $this->passwordHashing = $passwordHashing; $this->tokenStorage = $tokenStorage; } public function buildForm(FormBuilderInterface $builder, array $options): void { $defaultOptions = [ 'required' => $options['required'], 'invalid_message' => $options['invalid_message'], 'invalid_message_parameters' => $options['invalid_message_parameters'], ]; $passwordOptions = $options['password_options'] + $defaultOptions; $algorithm = $options['password_algorithm']; $plainPassword = ''; if ($options['password_confirm_current']) { if (!class_exists(Callback::class)) { throw new \LogicException('Password validation requires "symfony/validator".'); } $passwordOptions = self::withConstraint($passwordOptions, new Callback(function (?string $value, ExecutionContextInterface $context) use ($algorithm, $passwordOptions, &$plainPassword): void { $valid = true; if (null === $value || '' === $value || null === $this->tokenStorage || null === ($token = $this->tokenStorage->getToken()) || !($user = $token->getUser()) instanceof UserInterface) { $valid = false; } else { $algorithm = null === $algorithm && null !== ($salt = $user->getSalt()) ? PasswordAlgorithm::createLegacySalted(new PasswordSalt($salt)) : (is_callable($algorithm) ? $algorithm() : $algorithm); $valid = $this->passwordHashing->isValid($user->getPassword(), $plainPassword, $algorithm); } if (!$valid) { /** @var FormInterface $form */ $form = $context->getObject(); $form->addError(new FormError($passwordOptions['invalid_message'], $passwordOptions['invalid_message'], $passwordOptions['invalid_message_parameters'], null, $this)); } })); } $builder->add('password', PasswordType::class, $passwordOptions); $builder->get('password')->addModelTransformer(new CallbackTransformer(function (?string $value): ?string { return null; }, function (?string $value) use ($algorithm, &$plainPassword): ?string { return null === $value ? null : $this->passwordHashing->hash($plainPassword = $value, is_callable($algorithm) ? $algorithm() : $algorithm); })); if ($options['password_confirm']) { if (!class_exists(Callback::class)) { throw new \LogicException('Password validation requires "symfony/validator".'); } $passwordConfirmOptions = ['mapped' => false] + $options['password_confirm_options'] + $defaultOptions; $passwordConfirmOptions = self::withConstraint($passwordConfirmOptions, new Callback(function (?string $value, ExecutionContextInterface $context) use ($algorithm, $passwordConfirmOptions): void { if (null === $value || '' === $value) { return; } /** @var FormInterface $form */ $form = $context->getObject(); /** @var FormInterface $root */ $root = $form->getParent(); if (null === $password = $root->get('password')->getData()) { return; } if (!$this->passwordHashing->isValid($password, $value, is_callable($algorithm) ? $algorithm() : $algorithm)) { /** @var FormInterface $form */ $form = $context->getObject(); $form->addError(new FormError($passwordConfirmOptions['invalid_message'], $passwordConfirmOptions['invalid_message'], $passwordConfirmOptions['invalid_message_parameters'], null, $this)); } })); $builder->add('confirmation', PasswordType::class, $passwordConfirmOptions); } } public function configureOptions(OptionsResolver $resolver): void { $resolver->setDefaults([ 'inherit_data' => true, 'password_algorithm' => null, 'password_confirm' => false, 'password_confirm_current' => false, 'password_confirm_options' => function (Options $options, $value) { return $value ?? $options['password_options']; }, 'password_options' => [], ]); $resolver->setAllowedTypes('password_algorithm', ['null', 'callable', PasswordAlgorithm::class]); $resolver->setAllowedTypes('password_confirm', ['bool']); $resolver->setAllowedTypes('password_confirm_current', ['bool']); $resolver->setAllowedTypes('password_confirm_options', ['null', 'array']); $resolver->setAllowedTypes('password_options', ['array']); } private static function withConstraint(array $options, Constraint $constraint): array { if (!isset($options['constraints'])) { $options['constraints'] = []; } elseif (!is_array($options['constraints'])) { $options['constraints'] = [$options['constraints']]; } $options['constraints'][] = $constraint; return $options; } } msgphp-0.4.3/src/User/Infra/Security/000077500000000000000000000000001327361626700174045ustar00rootroot00000000000000msgphp-0.4.3/src/User/Infra/Security/DataCollector.php000066400000000000000000000063171327361626700226440ustar00rootroot00000000000000 * * @todo consider decorating instead * * @internal */ final class DataCollector extends BaseDataCollector { private $repository; private $factory; public function __construct(TokenStorageInterface $tokenStorage = null, RoleHierarchyInterface $roleHierarchy = null, LogoutUrlGenerator $logoutUrlGenerator = null, AccessDecisionManagerInterface $accessDecisionManager = null, FirewallMapInterface $firewallMap = null, TraceableFirewallListener $firewall = null, UserRepositoryInterface $repository = null, EntityAwareFactoryInterface $factory = null) { parent::__construct($tokenStorage, $roleHierarchy, $logoutUrlGenerator, $accessDecisionManager, $firewallMap, $firewall); $this->repository = $repository; $this->factory = $factory; } public function collect(Request $request, Response $response, \Exception $exception = null): void { parent::collect($request, $response, $exception); if (!isset($this->data['token'])) { return; } /** @var TokenInterface $token */ $token = $this->data['token']; $user = $token->getUser(); if ($user instanceof SecurityUser) { $this->data['user'] = $this->getUsername($user->getUsername()); } foreach ($token->getRoles() as $role) { if (!$role instanceof SwitchUserRole) { continue; } $impersonatorUser = $role->getSource()->getUser(); if ($impersonatorUser instanceof SecurityUser) { $this->data['impersonator_user'] = $this->getUsername($impersonatorUser->getUsername()); break; } } } private function getUsername(string $user): string { if (null === $this->repository) { return $user; } if (null === $this->factory) { throw new \LogicException('No entity factory set.'); } try { return $this->repository->find($this->factory->identify(User::class, $user)) ->getCredential() ->getUsername(); } catch (EntityNotFoundException $e) { return $user; } } } msgphp-0.4.3/src/User/Infra/Security/Jwt/000077500000000000000000000000001327361626700201505ustar00rootroot00000000000000msgphp-0.4.3/src/User/Infra/Security/Jwt/SecurityUserProvider.php000066400000000000000000000034611327361626700250460ustar00rootroot00000000000000 */ final class SecurityUserProvider implements UserProviderWithPayloadSupportsInterface { private $provider; private $repository; private $factory; public function __construct(BaseSecurityUserProvider $provider, UserRepositoryInterface $repository, EntityAwareFactoryInterface $factory) { $this->provider = $provider; $this->repository = $repository; $this->factory = $factory; } public function loadUserByUsernameAndPayload($username, array $payload): UserInterface { try { $user = $this->repository->find($this->factory->identify(User::class, $username)); } catch (EntityNotFoundException $e) { throw new UsernameNotFoundException($e->getMessage()); } return $this->provider->fromUser($user); } public function loadUserByUsername($username): UserInterface { return $this->provider->loadUserByUsername($username); } public function refreshUser(UserInterface $user): UserInterface { return $this->provider->refreshUser($user); } public function supportsClass($class): bool { return $this->provider->supportsClass($class); } } msgphp-0.4.3/src/User/Infra/Security/PasswordHashing.php000066400000000000000000000022401327361626700232170ustar00rootroot00000000000000 */ final class PasswordHashing implements PasswordHashingInterface { private $hashing; public function __construct(SymfonyPasswordHashingInterface $hashing) { $this->hashing = $hashing; } public function hash(string $plainPassword, PasswordAlgorithm $algorithm = null): string { return $this->hashing->encodePassword($plainPassword, self::getSalt($algorithm)); } public function isValid(string $hashedPassword, string $plainPassword, PasswordAlgorithm $algorithm = null): bool { return $this->hashing->isPasswordValid($hashedPassword, $plainPassword, self::getSalt($algorithm)); } private static function getSalt(PasswordAlgorithm $algorithm = null): string { return null === $algorithm || null === $algorithm->salt || empty($algorithm->salt->token) ? '' : $algorithm->salt->token; } } msgphp-0.4.3/src/User/Infra/Security/SecurityUser.php000066400000000000000000000036351327361626700225720ustar00rootroot00000000000000 */ final class SecurityUser implements UserInterface, EquatableInterface, \Serializable { private $id; private $roles; private $password; private $passwordSalt; public function __construct(User $user, array $roles = []) { $this->id = $user->getId()->toString(); $this->roles = $roles; $credential = $user->getCredential(); if ($credential instanceof PasswordProtectedInterface) { $this->password = $credential->getPassword(); $algorithm = $credential->getPasswordAlgorithm(); if (null !== $algorithm->salt) { $this->passwordSalt = $algorithm->salt->token; } } } public function getUsername(): string { return $this->id; } public function getRoles(): array { return $this->roles; } public function getPassword(): string { return $this->password ?? ''; } public function getSalt(): ?string { return $this->passwordSalt; } public function eraseCredentials(): void { $this->password = ''; $this->passwordSalt = null; } public function isEqualTo(UserInterface $user) { return $user instanceof self && $this->id === $user->getUsername(); } public function serialize(): string { return serialize([$this->id, $this->roles, $this->password, $this->passwordSalt]); } public function unserialize($serialized): void { list($this->id, $this->roles, $this->password, $this->passwordSalt) = unserialize($serialized); } } msgphp-0.4.3/src/User/Infra/Security/SecurityUserProvider.php000066400000000000000000000042571327361626700243060ustar00rootroot00000000000000 */ final class SecurityUserProvider implements UserProviderInterface { public const DEFAULT_ROLE = 'ROLE_DEFAULT'; private $repository; private $factory; private $rolesProvider; public function __construct(UserRepositoryInterface $repository, EntityAwareFactoryInterface $factory, UserRolesProviderInterface $rolesProvider = null) { $this->repository = $repository; $this->factory = $factory; $this->rolesProvider = $rolesProvider; } public function loadUserByUsername($username): UserInterface { try { $user = $this->repository->findByUsername($username); } catch (EntityNotFoundException $e) { throw new UsernameNotFoundException($e->getMessage()); } return $this->fromUser($user); } public function refreshUser(UserInterface $user): UserInterface { if (!$user instanceof SecurityUser) { throw new UnsupportedUserException(sprintf('Unsupported user "%s".', get_class($user))); } try { $user = $this->repository->find($this->factory->identify(User::class, $user->getUsername())); } catch (EntityNotFoundException $e) { throw new UsernameNotFoundException($e->getMessage()); } return $this->fromUser($user); } public function supportsClass($class): bool { return SecurityUser::class === $class; } public function fromUser(User $user): SecurityUser { return new SecurityUser($user, $this->rolesProvider ? $this->rolesProvider->getRoles($user) : [self::DEFAULT_ROLE]); } } msgphp-0.4.3/src/User/Infra/Security/TokenStorageAwareTrait.php000066400000000000000000000024151327361626700245100ustar00rootroot00000000000000 * * @internal */ trait TokenStorageAwareTrait { private $tokenStorage; private $repository; private $factory; public function __construct(TokenStorageInterface $tokenStorage, UserRepositoryInterface $repository, EntityAwareFactoryInterface $factory) { $this->tokenStorage = $tokenStorage; $this->repository = $repository; $this->factory = $factory; } private function isUser(): bool { return null !== ($token = $this->tokenStorage->getToken()) && $token->getUser() instanceof SecurityUser; } private function toUser(): ?User { if (null === $token = $this->tokenStorage->getToken()) { return null; } $user = $token->getUser(); if (!$user instanceof SecurityUser) { return null; } return $this->repository->find($this->factory->identify(User::class, $user->getUsername())); } } msgphp-0.4.3/src/User/Infra/Security/UserArgumentValueResolver.php000066400000000000000000000014561327361626700252630ustar00rootroot00000000000000 */ final class UserArgumentValueResolver implements ArgumentValueResolverInterface { use TokenStorageAwareTrait; public function supports(Request $request, ArgumentMetadata $argument): bool { return is_a($argument->getType(), User::class, true) ? ($argument->isNullable() || $this->isUser()) : false; } public function resolve(Request $request, ArgumentMetadata $argument): \Generator { yield $this->toUser(); } } msgphp-0.4.3/src/User/Infra/Security/UserParamConverter.php000066400000000000000000000017401327361626700237060ustar00rootroot00000000000000 */ final class UserParamConverter implements ParamConverterInterface { public const NAME = 'msgphp.current_user'; use TokenStorageAwareTrait; public function apply(Request $request, ParamConverter $configuration): bool { if (!$request->attributes->has($param = $configuration->getName())) { $request->attributes->set($param, $this->toUser()); } return true; } public function supports(ParamConverter $configuration): bool { return is_a($configuration->getClass(), User::class, true) ? ($configuration->isOptional() || $this->isUser()) : false; } } msgphp-0.4.3/src/User/Infra/Security/UserRolesProviderInterface.php000066400000000000000000000004471327361626700254010ustar00rootroot00000000000000 */ interface UserRolesProviderInterface { /** * @return string[] */ public function getRoles(User $user): array; } msgphp-0.4.3/src/User/Infra/Uuid/000077500000000000000000000000001327361626700165035ustar00rootroot00000000000000msgphp-0.4.3/src/User/Infra/Uuid/UserId.php000066400000000000000000000004171327361626700204110ustar00rootroot00000000000000 */ final class UserId extends DomainId implements UserIdInterface { } msgphp-0.4.3/src/User/Infra/Validator/000077500000000000000000000000001327361626700175225ustar00rootroot00000000000000msgphp-0.4.3/src/User/Infra/Validator/ExistingUsername.php000066400000000000000000000005541327361626700235310ustar00rootroot00000000000000 */ final class ExistingUsername extends Constraint { public const DOES_NOT_EXIST_ERROR = '4a8b28f7-a2b5-4435-9dd8-3be5188d23f0'; public $message = 'This value is not valid.'; } msgphp-0.4.3/src/User/Infra/Validator/ExistingUsernameValidator.php000066400000000000000000000023171327361626700253760ustar00rootroot00000000000000 */ final class ExistingUsernameValidator extends ConstraintValidator { private $repository; public function __construct(UserRepositoryInterface $repository) { $this->repository = $repository; } public function validate($value, Constraint $constraint): void { if (!$constraint instanceof ExistingUsername) { throw new UnexpectedTypeException($constraint, ExistingUsername::class); } if (null === $value || '' === ($value = (string) $value)) { return; } if (!$this->repository->usernameExists($value)) { $this->context->buildViolation($constraint->message) ->setParameter('{{ value }}', $value) ->setInvalidValue($value) ->setCode(ExistingUsername::DOES_NOT_EXIST_ERROR) ->addViolation(); } } } msgphp-0.4.3/src/User/Infra/Validator/UniqueUsername.php000066400000000000000000000005511327361626700232020ustar00rootroot00000000000000 */ final class UniqueUsername extends Constraint { public const IS_NOT_UNIQUE_ERROR = '37c4ba30-07ae-48e5-9767-19764e027346'; public $message = 'This value is not valid.'; } msgphp-0.4.3/src/User/Infra/Validator/UniqueUsernameValidator.php000066400000000000000000000023051327361626700250470ustar00rootroot00000000000000 */ final class UniqueUsernameValidator extends ConstraintValidator { private $repository; public function __construct(UserRepositoryInterface $repository) { $this->repository = $repository; } public function validate($value, Constraint $constraint): void { if (!$constraint instanceof UniqueUsername) { throw new UnexpectedTypeException($constraint, UniqueUsername::class); } if (null === $value || '' === ($value = (string) $value)) { return; } if ($this->repository->usernameExists($value)) { $this->context->buildViolation($constraint->message) ->setParameter('{{ value }}', $value) ->setInvalidValue($value) ->setCode(UniqueUsername::IS_NOT_UNIQUE_ERROR) ->addViolation(); } } } msgphp-0.4.3/src/User/LICENSE000066400000000000000000000020601327361626700155410ustar00rootroot00000000000000MIT License Copyright (c) 2017 Roland Franssen Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. msgphp-0.4.3/src/User/Password/000077500000000000000000000000001327361626700163405ustar00rootroot00000000000000msgphp-0.4.3/src/User/Password/PasswordAlgorithm.php000066400000000000000000000032511327361626700225230ustar00rootroot00000000000000 */ final class PasswordAlgorithm { public const DEFAULT_LEGACY = 'sha512'; /** @var int|string */ public $type; /** @var array|null */ public $options; /** @var bool */ public $legacy; /** @var bool|null */ public $encodeBase64; /** @var PasswordSalt|null */ public $salt; /** * @see https://secure.php.net/manual/en/function.password-hash.php */ public static function create(int $type = \PASSWORD_DEFAULT, array $options = []): self { $instance = new self($type); $instance->options = $options; return $instance; } /** * @see https://secure.php.net/manual/en/function.hash.php */ public static function createLegacy(string $type = self::DEFAULT_LEGACY): self { $instance = new self($type, true); $instance->encodeBase64 = false; return $instance; } public static function createLegacyBase64Encoded(string $type = self::DEFAULT_LEGACY): self { $instance = self::createLegacy($type); $instance->encodeBase64 = true; return $instance; } public static function createLegacySalted(PasswordSalt $salt, bool $encodeBase64 = true, string $type = self::DEFAULT_LEGACY): self { $instance = $encodeBase64 ? self::createLegacyBase64Encoded($type) : self::createLegacy($type); $instance->salt = $salt; return $instance; } private function __construct($type, bool $legacy = false) { $this->type = $type; $this->legacy = $legacy; } } msgphp-0.4.3/src/User/Password/PasswordHashing.php000066400000000000000000000045761327361626700221710ustar00rootroot00000000000000 */ final class PasswordHashing implements PasswordHashingInterface { private $defaultAlgorithm; private $deprecateLegacyApi; public function __construct(PasswordAlgorithm $defaultAlgorithm = null, bool $deprecateLegacyApi = true) { $this->defaultAlgorithm = $defaultAlgorithm ?? PasswordAlgorithm::create(); $this->deprecateLegacyApi = $deprecateLegacyApi; } public function hash(string $plainPassword, PasswordAlgorithm $algorithm = null): string { $algorithm = $algorithm ?? $this->defaultAlgorithm; if (!$algorithm->legacy) { return password_hash($plainPassword, $algorithm->type, $algorithm->options); } if ($this->deprecateLegacyApi) { @trigger_error(sprintf('Using PHP\'s legacy password API is deprecated and should be avoided. Create a non-legacy algorithm using "%s::create()" instead.', PasswordAlgorithm::class), \E_USER_DEPRECATED); } if (null !== $algorithm->salt) { if (1 > $algorithm->salt->iterations) { throw new \LogicException(sprintf('No. of password salt iterations must be 1 or higher, got %d.', $algorithm->salt->iterations)); } if (2 !== ($c = substr_count($algorithm->salt->format, '%s'))) { throw new \LogicException(sprintf('Password salt format should have exactly 2 value placeholders, found %d.', $c)); } $salted = sprintf($algorithm->salt->format, $plainPassword, $algorithm->salt->token); $hash = hash($algorithm->type, $salted, true); for ($i = 1; $i < $algorithm->salt->iterations; ++$i) { $hash = hash($algorithm->type, $hash.$salted, true); } } else { $hash = hash($algorithm->type, $plainPassword, true); } return $algorithm->encodeBase64 ? base64_encode($hash) : bin2hex($hash); } public function isValid(string $hashedPassword, string $plainPassword, PasswordAlgorithm $algorithm = null): bool { $algorithm = $algorithm ?? $this->defaultAlgorithm; return $algorithm->legacy ? hash_equals($hashedPassword, $this->hash($plainPassword, $algorithm)) : password_verify($plainPassword, $hashedPassword); } } msgphp-0.4.3/src/User/Password/PasswordHashingInterface.php000066400000000000000000000005761327361626700240060ustar00rootroot00000000000000 */ interface PasswordHashingInterface { public function hash(string $plainPassword, PasswordAlgorithm $algorithm = null): string; public function isValid(string $hashedPassword, string $plainPassword, PasswordAlgorithm $algorithm = null): bool; } msgphp-0.4.3/src/User/Password/PasswordProtectedInterface.php000066400000000000000000000005751327361626700243550ustar00rootroot00000000000000 */ interface PasswordProtectedInterface { public function getPassword(): string; public function getPasswordAlgorithm(): PasswordAlgorithm; } msgphp-0.4.3/src/User/Password/PasswordSalt.php000066400000000000000000000006651327361626700215060ustar00rootroot00000000000000 */ final class PasswordSalt { public $token; public $iterations; public $format; public function __construct(string $token, int $iterations = 5000, string $format = '%s{%s}') { $this->token = $token; $this->iterations = $iterations; $this->format = $format; } } msgphp-0.4.3/src/User/README.md000066400000000000000000000036321327361626700160210ustar00rootroot00000000000000# User domain layer A domain layer providing basic user management. [![Latest Stable Version](https://poser.pugx.org/msgphp/user/v/stable)](https://packagist.org/packages/msgphp/user) This package is part of the _Message driven PHP_ project. > [MsgPHP](https://msgphp.github.io/) is a project that aims to provide (common) message based domain layers for your application. It has a low development time overhead and avoids being overly opinionated. ## Installation ```bash composer require msgphp/user ``` ## Features - Doctrine persistence - Symfony console commands - Symfony security infrastructure - Symfony validators - Credential independent (supports e-mail, nickname, etc.) - Multiple username / credential support - Primary and secondary user e-mails - Disabled / enabled users - User roles - User attribute values ## Blog posts - [Adding user management to your Symfony application](https://medium.com/@ro0NL/adding-user-management-to-your-symfony-application-ceeefe2a2e9) - [Commanding a decoupled User entity](https://medium.com/@ro0NL/commanding-a-decoupled-user-entity-aee8723c43e5) - [Decoupling the User entity with a new Symfony User Bundle](https://medium.com/@ro0NL/decoupling-the-user-entity-with-a-new-symfony-user-bundle-7d2d5d85bdf9) - [Building a new Symfony User Bundle](https://medium.com/@ro0NL/building-a-new-symfony-user-bundle-b4fe5a9d9d80) ## Documentation - Read the [main documentation](https://msgphp.github.io/docs/) - Browse the [API documentation](https://msgphp.github.io/api/MsgPhp/User.html) - Try the Symfony [demo application](https://github.com/msgphp/symfony-demo-app) - Get support on [Symfony's Slack `#msgphp` channel](https://symfony.com/slack-invite) or [raise an issue](https://github.com/msgphp/msgphp/issues/new) ## Contributing This repository is **READ ONLY**. Issues and pull requests should be submitted in the [main development repository](https://github.com/msgphp/msgphp). msgphp-0.4.3/src/User/Repository/000077500000000000000000000000001327361626700167155ustar00rootroot00000000000000msgphp-0.4.3/src/User/Repository/RoleRepositoryInterface.php000066400000000000000000000011111327361626700242420ustar00rootroot00000000000000 */ interface RoleRepositoryInterface { /** * @return DomainCollectionInterface|Role[] */ public function findAll(int $offset = 0, int $limit = 0): DomainCollectionInterface; public function find(string $name): Role; public function exists(string $name): bool; public function save(Role $role): void; public function delete(Role $role): void; } msgphp-0.4.3/src/User/Repository/UserAttributeValueRepositoryInterface.php000066400000000000000000000030651327361626700271520ustar00rootroot00000000000000 */ interface UserAttributeValueRepositoryInterface { /** * @return DomainCollectionInterface|UserAttributeValue[] */ public function findAllByAttributeId(AttributeIdInterface $attributeId, int $offset = 0, int $limit = 0): DomainCollectionInterface; /** * @return DomainCollectionInterface|UserAttributeValue[] */ public function findAllByAttributeIdAndValue(AttributeIdInterface $attributeId, $value, int $offset = 0, int $limit = 0): DomainCollectionInterface; /** * @return DomainCollectionInterface|UserAttributeValue[] */ public function findAllByUserId(UserIdInterface $userId, int $offset = 0, int $limit = 0): DomainCollectionInterface; /** * @return DomainCollectionInterface|UserAttributeValue[] */ public function findAllByUserIdAndAttributeId(UserIdInterface $userId, AttributeIdInterface $attributeId, int $offset = 0, int $limit = 0): DomainCollectionInterface; public function find(AttributeValueIdInterface $attributeValueId): UserAttributeValue; public function exists(AttributeValueIdInterface $attributeValueId): bool; public function save(UserAttributeValue $userAttributeValue): void; public function delete(UserAttributeValue $userAttributeValue): void; } msgphp-0.4.3/src/User/Repository/UserEmailRepositoryInterface.php000066400000000000000000000012651327361626700252410ustar00rootroot00000000000000 */ interface UserEmailRepositoryInterface { /** * @return DomainCollectionInterface|UserEmail[] */ public function findAllByUserId(UserIdInterface $userId, int $offset = 0, int $limit = 0): DomainCollectionInterface; public function find(string $email): UserEmail; public function exists(string $email): bool; public function save(UserEmail $userEmail): void; public function delete(UserEmail $userEmail): void; } msgphp-0.4.3/src/User/Repository/UserRepositoryInterface.php000066400000000000000000000013621327361626700242670ustar00rootroot00000000000000 */ interface UserRepositoryInterface { /** * @return DomainCollectionInterface|User[] */ public function findAll(int $offset = 0, int $limit = 0): DomainCollectionInterface; public function find(UserIdInterface $id): User; public function findByUsername(string $username): User; public function exists(UserIdInterface $id): bool; public function usernameExists(string $username): bool; public function save(User $user): void; public function delete(User $user): void; } msgphp-0.4.3/src/User/Repository/UserRoleRepositoryInterface.php000066400000000000000000000013451327361626700251120ustar00rootroot00000000000000 */ interface UserRoleRepositoryInterface { /** * @return DomainCollectionInterface|UserRole[] */ public function findAllByUserId(UserIdInterface $userId, int $offset = 0, int $limit = 0): DomainCollectionInterface; public function find(UserIdInterface $userId, string $roleName): UserRole; public function exists(UserIdInterface $userId, string $roleName): bool; public function save(UserRole $userRole): void; public function delete(UserRole $userRole): void; } msgphp-0.4.3/src/User/Repository/UsernameRepositoryInterface.php000066400000000000000000000014321327361626700251260ustar00rootroot00000000000000 */ interface UsernameRepositoryInterface { /** * @return DomainCollectionInterface|Username[] */ public function findAll(int $offset = 0, int $limit = 0): DomainCollectionInterface; /** * @return DomainCollectionInterface|Username[] */ public function findAllFromTargets(int $offset = 0, int $limit = 0): DomainCollectionInterface; public function find(string $username): Username; public function exists(string $username): bool; public function save(Username $username): void; public function delete(Username $username): void; } msgphp-0.4.3/src/User/UserId.php000066400000000000000000000003301327361626700164360ustar00rootroot00000000000000 */ final class UserId extends DomainId implements UserIdInterface { } msgphp-0.4.3/src/User/UserIdInterface.php000066400000000000000000000003261327361626700202640ustar00rootroot00000000000000 */ interface UserIdInterface extends DomainIdInterface { } msgphp-0.4.3/src/User/composer.json000066400000000000000000000024251327361626700172630ustar00rootroot00000000000000{ "name": "msgphp/user", "type": "library", "license": "MIT", "description": "User domain layer", "keywords": ["user", "security"], "authors": [ { "name": "Roland Franssen", "email": "franssen.roland@gmail.com" } ], "minimum-stability": "dev", "autoload": { "psr-4": { "MsgPhp\\User\\": "" }, "exclude-from-classmap": ["/Tests/"] }, "require": { "msgphp/domain": "^0.4|^1.0" }, "require-dev": { "doctrine/orm": "^2.6", "lexik/jwt-authentication-bundle": "^2.5@dev", "msgphp/eav": "^0.3|^1.0", "sensio/framework-extra-bundle": "^5.1", "symfony/console": "^3.4|^4.0", "symfony/form": "^3.4|^4.0", "symfony/http-kernel": "^3.4|^4.0", "symfony/phpunit-bridge": "^3.4|^4.0", "symfony/security-core": "^3.4|^4.0", "symfony/validator": "^3.4|^4.0", "symfony/var-dumper": "^3.4|^4.0" }, "suggest": { "msgphp/eav": "To enable user attribute values" }, "config": { "preferred-install": { "*": "dist" }, "sort-packages": true }, "extra": { "branch-alias": { "dev-master": "1.0-dev" } } } msgphp-0.4.3/src/UserBundle/000077500000000000000000000000001327361626700156705ustar00rootroot00000000000000msgphp-0.4.3/src/UserBundle/.gitattributes000066400000000000000000000000641327361626700205630ustar00rootroot00000000000000Tests/ export-ignore phpunit.xml.dist export-ignore msgphp-0.4.3/src/UserBundle/.gitignore000066400000000000000000000000471327361626700176610ustar00rootroot00000000000000/composer.lock /composer.phar /vendor/ msgphp-0.4.3/src/UserBundle/DependencyInjection/000077500000000000000000000000001327361626700216115ustar00rootroot00000000000000msgphp-0.4.3/src/UserBundle/DependencyInjection/Compiler/000077500000000000000000000000001327361626700233635ustar00rootroot00000000000000msgphp-0.4.3/src/UserBundle/DependencyInjection/Compiler/CleanupPass.php000066400000000000000000000100031327361626700263040ustar00rootroot00000000000000 * * @internal */ final class CleanupPass implements CompilerPassInterface { public function process(ContainerBuilder $container): void { $doctrineRepositoryIds = []; foreach (glob(Configuration::getPackageDir().'/Infra/Doctrine/Repository/*Repository.php') as $file) { $doctrineRepositoryIds[] = 'MsgPhp\\User\\Infra\\Doctrine\\Repository\\'.basename($file, '.php'); } ContainerHelper::removeIf($container, !$container->has(DoctrineEntityManager::class), $doctrineRepositoryIds); ContainerHelper::removeIf($container, !$container->has(SecurityTokenStorage::class), [ SecurityInfra\UserParamConverter::class, SecurityInfra\UserArgumentValueResolver::class, ]); ContainerHelper::removeIf($container, !$container->has(Repository\RoleRepositoryInterface::class), [ ConsoleInfra\Command\AddUserRoleCommand::class, ConsoleInfra\Command\DeleteUserRoleCommand::class, ]); ContainerHelper::removeIf($container, !$container->has(Repository\UserRepositoryInterface::class), [ Command\Handler\ChangeUserCredentialHandler::class, Command\Handler\ConfirmUserHandler::class, Command\Handler\CreateUserHandler::class, Command\Handler\DeleteUserHandler::class, Command\Handler\DisableUserHandler::class, Command\Handler\EnableUserHandler::class, Command\Handler\RequestUserPasswordHandler::class, ConsoleInfra\Command\AddUserRoleCommand::class, ConsoleInfra\Command\ChangeUserCredentialCommand::class, ConsoleInfra\Command\ConfirmUserCommand::class, ConsoleInfra\Command\CreateUserCommand::class, ConsoleInfra\Command\DeleteUserCommand::class, ConsoleInfra\Command\DeleteUserRoleCommand::class, ConsoleInfra\Command\DisableUserCommand::class, ConsoleInfra\Command\EnableUserCommand::class, SecurityInfra\Jwt\SecurityUserProvider::class, SecurityInfra\SecurityUserProvider::class, SecurityInfra\UserParamConverter::class, SecurityInfra\UserArgumentValueResolver::class, ValidatorInfra\ExistingUsernameValidator::class, ValidatorInfra\UniqueUsernameValidator::class, ]); ContainerHelper::removeIf($container, !$container->has(Repository\UsernameRepositoryInterface::class), [ ConsoleInfra\Command\SynchronizeUsernamesCommand::class, ]); ContainerHelper::removeIf($container, !$container->has(Repository\UserAttributeValueRepositoryInterface::class), [ Command\Handler\AddUserAttributeValueHandler::class, Command\Handler\ChangeUserAttributeValueHandler::class, Command\Handler\DeleteUserAttributeValueHandler::class, ]); ContainerHelper::removeIf($container, !$container->has(Repository\UserEmailRepositoryInterface::class), [ Command\Handler\AddUserEmailHandler::class, Command\Handler\DeleteUserEmailHandler::class, ]); ContainerHelper::removeIf($container, !$container->has(Repository\UserRoleRepositoryInterface::class), [ Command\Handler\AddUserRoleHandler::class, Command\Handler\DeleteUserRoleHandler::class, ]); } } msgphp-0.4.3/src/UserBundle/DependencyInjection/Configuration.php000066400000000000000000000174221327361626700251370ustar00rootroot00000000000000 * * @internal */ final class Configuration implements ConfigurationInterface { public const AGGREGATE_ROOTS = [ Entity\User::class => UserIdInterface::class, ]; public const IDENTITY_MAPPING = [ Entity\Role::class => ['name'], Entity\UserAttributeValue::class => ['attributeValue'], Entity\User::class => ['id'], Entity\Username::class => ['username'], Entity\UserRole::class => ['user', 'role'], Entity\UserEmail::class => ['email'], ]; public const DEFAULT_ID_CLASS_MAPPING = [ UserIdInterface::class => UserId::class, ]; public const UUID_CLASS_MAPPING = [ UserIdInterface::class => UuidInfra\UserId::class, ]; private const COMMAND_MAPPING = [ Entity\User::class => [ Command\CreateUserCommand::class => true, Command\DeleteUserCommand::class => true, Features\CanBeConfirmed::class => [ Command\ConfirmUserCommand::class, ], Features\CanBeEnabled::class => [ Command\DisableUserCommand::class, Command\EnableUserCommand::class, ], Entity\Features\ResettablePassword::class => [ Command\RequestUserPasswordCommand::class, ], ], Entity\UserAttributeValue::class => [ Command\AddUserAttributeValueCommand::class => true, Command\ChangeUserAttributeValueCommand::class => true, Command\DeleteUserAttributeValueCommand::class => true, ], Entity\UserEmail::class => [ Command\AddUserEmailCommand::class => true, Command\DeleteUserEmailCommand::class => true, Features\CanBeConfirmed::class => [ Command\ConfirmUserEmailCommand::class, ], ], Entity\UserRole::class => [ Command\AddUserRoleCommand::class => true, Command\DeleteUserRoleCommand::class => true, ], ]; public static function getPackageDir(): string { static $path; if (null === $path) { $path = dirname((new \ReflectionClass(UserIdInterface::class))->getFileName()); } return $path; } public function getConfigTreeBuilder(): TreeBuilder { /** @var NodeBuilder $children */ $children = ($treeBuilder = new TreeBuilder())->rootArray(Extension::ALIAS)->children(); $children ->classMappingNode('class_mapping') ->requireClasses([Entity\User::class]) ->disallowClasses([CredentialInterface::class, Entity\Username::class]) ->groupClasses([Entity\Role::class, Entity\UserRole::class]) ->subClassValues() ->end() ->classMappingNode('id_type_mapping') ->subClassKeys([DomainIdInterface::class]) ->end() ->classMappingNode('commands') ->typeOfValues('boolean') ->end() ->scalarNode('default_id_type') ->defaultValue(ConfigHelper::DEFAULT_ID_TYPE) ->cannotBeEmpty() ->end() ->arrayNode('username_lookup') ->requiresAtLeastOneElement() ->arrayPrototype() ->children() ->scalarNode('target') ->isRequired() ->cannotBeEmpty() ->validate() ->ifTrue(function ($value): bool { return Entity\Username::class === $value; }) ->thenInvalid('Target %s is not applicable.') ->end() ->validate() ->ifTrue(function ($value): bool { return !class_exists($value); }) ->thenInvalid('Target %s does not exists.') ->end() ->end() ->scalarNode('field')->isRequired()->cannotBeEmpty()->end() ->scalarNode('mapped_by')->defaultValue('user')->cannotBeEmpty()->end() ->end() ->end() ->validate() ->always(function (array $value): array { $result = []; foreach ($value as $lookup) { $result[$lookup['target']][$lookup['field']] = $lookup['mapped_by']; } return $result; }) ->end() ->end() ->end() ->validate() ->always(ConfigHelper::defaultBundleConfig( self::DEFAULT_ID_CLASS_MAPPING, array_fill_keys(ConfigHelper::UUID_TYPES, self::UUID_CLASS_MAPPING) )) ->end() ->validate() ->always(function (array $config): array { $userCredential = self::getUserCredential($userClass = $config['class_mapping'][Entity\User::class]); $config['username_field'] = $userCredential['username_field']; $config['class_mapping'][CredentialInterface::class] = $userCredential['class']; if ($config['username_lookup']) { if (isset($config['username_field'])) { $config['username_lookup'][$userClass][$config['username_field']] = null; } $config['class_mapping'][Entity\Username::class] = Entity\Username::class; } if (isset($config['username_field'])) { $config['commands'] += [Command\ChangeUserCredentialCommand::class => true]; } ConfigHelper::resolveCommandMappingConfig(self::COMMAND_MAPPING, $config['class_mapping'], $config['commands']); return $config; }) ->end(); return $treeBuilder; } private static function getUserCredential(string $userClass): array { $reflection = new \ReflectionMethod($userClass, 'getCredential'); if (Entity\User::class === $reflection->getDeclaringClass()->getName()) { return ['class' => Entity\Credential\Anonymous::class, 'username_field' => null]; } if (null === $type = $reflection->getReturnType()) { throw new \LogicException(sprintf('Method "%s::getCredential()" must have a return type set.', $userClass)); } if (Entity\Credential\Anonymous::class === $class = $type->getName()) { return ['class' => $class, 'username_field' => null]; } if ($type->isBuiltin() || !is_subclass_of($class, CredentialInterface::class)) { throw new \LogicException(sprintf('Method "%s::getCredential()" must return a sub class of "%s", got "%s".', $userClass, CredentialInterface::class, $class)); } if ($type->allowsNull()) { throw new \LogicException(sprintf('Method "%s::getCredential()" cannot be null-able.', $userClass)); } return ['class' => $class, 'username_field' => 'credential.'.$class::getUsernameField()]; } } msgphp-0.4.3/src/UserBundle/DependencyInjection/Extension.php000066400000000000000000000235741327361626700243110ustar00rootroot00000000000000 * * @internal */ final class Extension extends BaseExtension implements PrependExtensionInterface, CompilerPassInterface { public const ALIAS = 'msgphp_user'; public function getAlias(): string { return self::ALIAS; } public function getConfiguration(array $config, ContainerBuilder $container): ConfigurationInterface { return new Configuration(); } public function load(array $configs, ContainerBuilder $container): void { $loader = new PhpFileLoader($container, new FileLocator(dirname(__DIR__).'/Resources/config')); $config = $this->processConfiguration($this->getConfiguration($configs, $container), $configs); // default infra $loader->load('services.php'); ContainerHelper::configureIdentityMapping($container, $config['class_mapping'], Configuration::IDENTITY_MAPPING); ContainerHelper::configureEntityFactory($container, $config['class_mapping'], Configuration::AGGREGATE_ROOTS); // message infra $loader->load('message.php'); ContainerHelper::configureCommandMessages($container, $config['class_mapping'], $config['commands']); ContainerHelper::configureEventMessages($container, $config['class_mapping'], array_map(function (string $file): string { return 'MsgPhp\\User\\Event\\'.basename($file, '.php'); }, glob(Configuration::getPackageDir().'/Event/*Event.php'))); // persistence infra if (class_exists(DoctrineOrmVersion::class)) { $this->loadDoctrineOrm($config, $loader, $container); } // framework infra if (class_exists(Security::class)) { $loader->load('security.php'); } if (class_exists(Form::class)) { $loader->load('form.php'); } if (class_exists(Validation::class)) { $loader->load('validator.php'); } if (class_exists(TwigEnvironment::class)) { $loader->load('twig.php'); } if (class_exists(ConsoleEvents::class)) { $loader->load('console.php'); $container->getDefinition(ConsoleInfra\Command\CreateUserCommand::class) ->setArgument('$contextFactory', ContainerHelper::registerConsoleClassContextFactory( $container, $config['class_mapping'][Entity\User::class] )); if (isset($config['class_mapping'][Entity\UserRole::class])) { $container->getDefinition(ConsoleInfra\Command\AddUserRoleCommand::class) ->setArgument('$contextFactory', ContainerHelper::registerConsoleClassContextFactory( $container, $config['class_mapping'][Entity\UserRole::class], BaseConsoleInfra\Context\ClassContextFactory::REUSE_DEFINITION )); } else { $container->removeDefinition(ConsoleInfra\Command\AddUserRoleCommand::class); $container->removeDefinition(ConsoleInfra\Command\DeleteUserRoleCommand::class); } if (isset($config['username_field'])) { $container->getDefinition(ConsoleInfra\Command\ChangeUserCredentialCommand::class) ->setArgument('$contextFactory', ContainerHelper::registerConsoleClassContextFactory( $container, $config['class_mapping'][CredentialInterface::class], BaseConsoleInfra\Context\ClassContextFactory::ALWAYS_OPTIONAL | BaseConsoleInfra\Context\ClassContextFactory::NO_DEFAULTS )); } else { $container->removeDefinition(ConsoleInfra\Command\ChangeUserCredentialCommand::class); } foreach (glob(Configuration::getPackageDir().'/Infra/Console/Command/*Command.php') as $file) { if (!$container->hasDefinition($id = 'MsgPhp\\User\\Infra\\Console\\Command\\'.basename($file, '.php'))) { continue; } $definition = $container->getDefinition($id); if (is_subclass_of($definition->getClass() ?? $id, MessageReceivingInterface::class)) { $definition->addTag('msgphp.domain.message_aware'); } } } } public function prepend(ContainerBuilder $container): void { $config = $this->processConfiguration($this->getConfiguration($configs = $container->getExtensionConfig($this->getAlias()), $container), $configs); ContainerHelper::configureDoctrineDbalTypes($container, $config['class_mapping'], $config['id_type_mapping'], [ UserIdInterface::class => DoctrineInfra\Type\UserIdType::class, ]); ContainerHelper::configureDoctrineOrmTargetEntities($container, $config['class_mapping']); if (ContainerHelper::hasBundle($container, TwigBundle::class)) { $container->prependExtensionConfig('twig', [ 'globals' => [ Twig\GlobalVariable::NAME => '@'.Twig\GlobalVariable::class, ], ]); } } public function process(ContainerBuilder $container): void { if ($container->hasDefinition('data_collector.security')) { $container->getDefinition('data_collector.security') ->setClass(SecurityInfra\DataCollector::class) ->setArgument('$repository', new Reference(Repository\UserRepositoryInterface::class, ContainerBuilder::NULL_ON_INVALID_REFERENCE)) ->setArgument('$factory', new Reference(EntityAwareFactoryInterface::class)); } } private function loadDoctrineOrm(array $config, LoaderInterface $loader, ContainerBuilder $container): void { $loader->load('doctrine.php'); if (isset($config['username_field'])) { $container->getDefinition(DoctrineInfra\Repository\UserRepository::class) ->setArgument('$usernameField', $config['username_field']); } if ($config['username_lookup']) { $container->getDefinition(DoctrineInfra\Event\UsernameListener::class) ->setArgument('$mapping', $config['username_lookup']) ->addTag('msgphp.domain.process_class_mapping', ['argument' => '$mapping', 'array_keys' => true]); $container->getDefinition(DoctrineInfra\Repository\UsernameRepository::class) ->setArgument('$targetMapping', $config['username_lookup']) ->addTag('msgphp.domain.process_class_mapping', ['argument' => '$targetMapping', 'array_keys' => true]); } else { $container->removeDefinition(DoctrineInfra\Event\UsernameListener::class); } ContainerHelper::configureDoctrineOrmMapping($container, self::getDoctrineMappingFiles($config, $container), [DoctrineInfra\EntityFieldsMapping::class]); ContainerHelper::configureDoctrineOrmRepositories($container, $config['class_mapping'], [ DoctrineInfra\Repository\RoleRepository::class => Entity\Role::class, DoctrineInfra\Repository\UserRepository::class => Entity\User::class, DoctrineInfra\Repository\UsernameRepository::class => Entity\Username::class, DoctrineInfra\Repository\UserAttributeValueRepository::class => Entity\UserAttributeValue::class, DoctrineInfra\Repository\UserRoleRepository::class => Entity\UserRole::class, DoctrineInfra\Repository\UserEmailRepository::class => Entity\UserEmail::class, ]); } private static function getDoctrineMappingFiles(array $config, ContainerBuilder $container): array { $baseDir = Configuration::getPackageDir().'/Infra/Doctrine/Resources/dist-mapping'; $files = array_flip(glob($baseDir.'/*.orm.xml')); if (!isset($config['class_mapping'][Entity\Role::class])) { unset($files[$baseDir.'/User.Entity.Role.orm.xml'], $files[$baseDir.'/User.Entity.UserRole.orm.xml']); } if (!isset($config['class_mapping'][Entity\UserEmail::class])) { unset($files[$baseDir.'/User.Entity.UserEmail.orm.xml']); } if (!isset($config['class_mapping'][Entity\Username::class])) { unset($files[$baseDir.'/User.Entity.Username.orm.xml']); } if (!ContainerHelper::hasBundle($container, MsgPhpEavBundle::class)) { unset($files[$baseDir.'/User.Entity.UserAttributeValue.orm.xml']); } return array_keys($files); } } msgphp-0.4.3/src/UserBundle/LICENSE000066400000000000000000000020601327361626700166730ustar00rootroot00000000000000MIT License Copyright (c) 2017 Roland Franssen Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. msgphp-0.4.3/src/UserBundle/Maker/000077500000000000000000000000001327361626700167275ustar00rootroot00000000000000msgphp-0.4.3/src/UserBundle/Maker/UserMaker.php000066400000000000000000000617641327361626700213540ustar00rootroot00000000000000 * * @internal */ final class UserMaker implements MakerInterface { private $classMapping; private $projectDir; private $credential; private $passwordReset = false; private $configs = []; private $services = []; private $writes = []; /** @var \ReflectionClass */ private $user; public function __construct(array $classMapping, string $projectDir) { $this->classMapping = $classMapping; $this->projectDir = $projectDir; } public static function getCommandName(): string { return 'make:user'; } public function configureCommand(Command $command, InputConfiguration $inputConfig): void { } public function configureDependencies(DependencyBuilder $dependencies): void { } public function interact(InputInterface $input, ConsoleStyle $io, Command $command): void { } public function generate(InputInterface $input, ConsoleStyle $io, Generator $generator): void { $this->credential = $this->user = null; $this->passwordReset = false; $this->configs = $this->services = $this->writes = []; if (!isset($this->classMapping[Entity\User::class])) { throw new \LogicException('User class not configured. Did you install the bundle using Symfony Recipes?'); } $this->user = new \ReflectionClass($this->classMapping[Entity\User::class]); $this->generateUser($io); $this->generateControllers($io); $this->generateConsole($io); if ($this->configs || $this->services) { $configFile = $this->projectDir.'/config/packages/msgphp_user.make.php'; $i = 0; while (file_exists($configFile)) { $configFile = $this->projectDir.'/config/packages/msgphp_user.make_'.++$i.'.php'; } array_unshift($this->writes, [$configFile, self::getSkeleton('config.php', [ 'config' => $this->configs ? var_export(array_merge_recursive(...$this->configs), true) : null, 'services' => $this->services, ])]); $this->configs = $this->services = []; } $writeAll = count($this->writes) > 1 && $io->confirm('Write all changes at once?'); while ($write = array_shift($this->writes)) { [$fileName, $contents] = $write; switch ($writeAll ? 'y' : $io->choice(sprintf('Write changes to %s?', preg_replace('~^'.preg_quote($this->projectDir.'/', '~').'~', './', $fileName)), ['n' => 'No', 's' => 'No, show new code', 'y' => 'Yes'], 'Yes')) { case 'n': continue 2; case 's': $io->writeln($contents); break; case 'y': default: if (!is_dir($parent = dirname($fileName))) { mkdir($parent, 0777, true); } file_put_contents($fileName, $contents); break; } } $io->success('Done!'); $io->note('Don\'t forget to update your database schema, if needed'); } private function generateUser(ConsoleStyle $io): void { $lines = file($fileName = $this->user->getFileName()); $traits = array_flip($this->user->getTraitNames()); $implementors = array_flip($this->user->getInterfaceNames()); $inClass = $inClassBody = $hasUses = $hasTraitUses = $hasImplements = false; $useLine = $traitUseLine = $implementsLine = $constructorLine = 0; $nl = null; $indent = ''; foreach ($tokens = token_get_all(implode('', $lines)) as $i => $token) { if (!is_array($token)) { if ('{' === $token && $inClass && !$inClassBody) { $inClassBody = true; } continue; } if ($inClassBody) { if (!$traitUseLine) { $traitUseLine = $token[2]; } } else { if (!$useLine) { $useLine = $token[2]; } } if (in_array($token[0], [\T_COMMENT, \T_DOC_COMMENT, \T_WHITESPACE], true)) { if (\T_WHITESPACE === $token[0]) { if (!$nl) { $nl = in_array($nl = trim($token[1], ' '), ["\n", "\r", "\r\n"], true) ? $nl : null; } if (!$indent && $inClassBody && $nl) { $spaces = explode($nl, $token[1]); $indent = end($spaces); } } continue; } if (\T_NAMESPACE === $token[0] && !$useLine) { $useLine = $token[2]; } elseif (\T_CLASS === $token[0] && !$inClass) { $inClass = true; } elseif (\T_USE === $token[0]) { if (!$inClass) { $useLine = $token[2]; $hasUses = true; } else { $traitUseLine = $token[2]; $hasTraitUses = true; } } elseif (\T_EXTENDS === $token[0] && $inClass) { $implementsLine = $tokens[2]; $j = $i + 1; while (isset($tokens[$j])) { if (isset($tokens[$j][0]) && \T_STRING === $tokens[$j][0]) { $implementsLine = $tokens[$j][2]; } elseif ('{' === $tokens[$j] || (isset($tokens[$j][0]) && \T_IMPLEMENTS === $tokens[$j][0])) { break; } ++$j; } } elseif (\T_IMPLEMENTS === $token[0] && $inClass) { $hasImplements = true; $implementsLine = $token[2]; $j = $i + 1; while (isset($tokens[$j])) { if (is_array($tokens[$j]) && \T_STRING === $tokens[$j][0]) { $implementsLine = $tokens[$j][2]; } elseif ('{' === $tokens[$j]) { break; } ++$j; } } elseif (\T_FUNCTION === $token[0]) { $constructorLine = $token[2]; $j = $i - 1; while (isset($tokens[$j])) { if (is_array($tokens[$j])) { $constructorLine = $tokens[$j][2]; } elseif (';' === $tokens[$j] || '}' === $tokens[$j]) { break; } --$j; } } } if (!$constructorLine) { $constructorLine = $traitUseLine; } $nl = $nl ?? \PHP_EOL; $addUses = $addTraitUses = $addImplementors = []; $write = false; $enableEventHandler = function () use ($implementors, &$addUses, &$addImplementors, &$addTraitUses): void { if (!isset($implementors[DomainEventHandlerInterface::class])) { $addUses[DomainEventHandlerInterface::class] = true; $addUses[DomainEventHandlerTrait::class] = true; $addImplementors['DomainEventHandlerInterface'] = true; $addTraitUses['DomainEventHandlerTrait'] = true; } }; $this->credential = $this->classMapping[CredentialInterface::class] ?? null; if (!$this->hasUsername() && $io->confirm('Generate a user credential?')) { $credentials = []; foreach (glob(Configuration::getPackageDir().'/Entity/Credential/*.php') as $file) { if ('Anonymous' === $credential = basename($file, '.php')) { continue; } $credentials[] = $credential; } $credential = $io->choice('Select credential type:', $credentials, 'EmailPassword'); $credentialClass = $this->credential = 'MsgPhp\\User\\Entity\\Credential\\'.$credential; $credentialTrait = 'MsgPhp\\User\\Entity\\Features\\'.($credentialName = $credential.'Credential'); $credentialSignature = self::getConstructorSignature(new \ReflectionClass($credentialClass)); $credentialInit = '$this->credential = new '.$credential.'('.self::getSignatureVariables($credentialSignature).');'; $addUses[$credentialClass] = true; if (!isset($traits[$credentialTrait])) { $addUses[$credentialTrait] = true; $addTraitUses[$credentialName] = true; $enableEventHandler(); } if (null !== $constructor = $this->user->getConstructor()) { $offset = $constructor->getStartLine() - 1; $length = $constructor->getEndLine() - $offset; $contents = preg_replace_callback_array([ '~^[^_]*+__construct\([^\)]*+\)~i' => function (array $match) use ($credentialSignature): string { $signature = substr($match[0], 0, -1); if ('' !== $credentialSignature) { $signature .= ('(' !== substr(rtrim($signature), -1) ? ', ' : '').$credentialSignature; } return $signature.')'; }, '~\s*+}\s*+$~s' => function ($match) use ($nl, $indent, $credential, $credentialInit): string { $indent = ltrim(substr($match[0], 0, strpos($match[0], '}')), "\r\n").' '; return $nl.$indent.$credentialInit.$match[0]; }, ], $oldContents = implode('', array_slice($lines, $offset, $length))); if ($contents !== $oldContents) { array_splice($lines, $offset, $length, $contents); $write = true; if ($traitUseLine > $offset + 1) { ++$traitUseLine; } } } else { $constructor = array_map(function (string $line) use ($nl, $indent): string { return $indent.$line.$nl; }, explode("\n", << $constructorLine) { $traitUseLine += 4; } } } $this->passwordReset = isset($traits[Entity\Features\ResettablePassword::class]); if (!$this->passwordReset && $this->hasPassword() && $io->confirm('Can users reset their password?')) { $addUses[Entity\Features\ResettablePassword::class] = true; $addTraitUses['ResettablePassword'] = true; $enableEventHandler(); } if (!isset($this->classMapping[Entity\Role::class]) && $io->confirm('Enable user roles?')) { $baseDir = dirname($this->user->getFileName()); $vars = ['ns' => $ns = $this->user->getNamespaceName()]; $addUses[Entity\Fields\RolesField::class] = true; $addTraitUses['RolesField'] = true; $this->writes[] = [$baseDir.'/Role.php', self::getSkeleton('entity/Role.php', $vars)]; $this->writes[] = [$baseDir.'/UserRole.php', self::getSkeleton('entity/UserRole.php', $vars)]; $this->configs[] = ['class_mapping' => [ Entity\Role::class => $ns.'\\Role', Entity\UserRole::class => $userRoleClass = $ns.'\\UserRole', ]]; $defaultRole = $io->ask('Provide a default role', 'ROLE_USER'); [$rolesProviderNs, $rolesProviderShortClass] = self::splitClass($rolesProviderClass = 'App\\Security\\UserRolesProvider'); $this->writes[] = [$this->getClassFileName($rolesProviderClass), self::getSkeleton('service/UserRolesProvider.php', [ 'ns' => $rolesProviderNs, 'class' => $rolesProviderShortClass, 'userClass' => $this->user->getName(), 'userRoleClass' => $userRoleClass, 'defaultRole' => $defaultRole, ])]; $this->services[] = <<set(${rolesProviderClass}::class) ->alias(MsgPhp\\User\\Infra\\Security\\UserRolesProviderInterface::class, ${rolesProviderClass}::class) PHP; } // if (!isset($traits[Features\CanBeEnabled::class]) && $io->confirm('Can users be enabled / disabled?')) { // $implementors[] = DomainEventHandlerInterface::class; // $addUses[Features\CanBeEnabled::class] = true; // $addTraitUses['CanBeEnabled'] = true; // $enableEventHandler(); // } // // if (!isset($traits[Features\CanBeConfirmed::class]) && $io->confirm('Can users be confirmed?')) { // $implementors[] = DomainEventHandlerInterface::class; // $addUses[Features\CanBeConfirmed::class] = true; // $addTraitUses['CanBeConfirmed'] = true; // $enableEventHandler(); // } if ($numUses = count($addUses)) { ksort($addUses); $uses = array_map(function (string $use) use ($nl): string { return 'use '.$use.';'.$nl; }, array_keys($addUses)); if (!$hasUses) { $uses[] = $nl; ++$implementsLine; ++$traitUseLine; } array_splice($lines, $useLine, 0, $uses); $write = true; $implementsLine += $numUses; $traitUseLine += $numUses; } if ($numTraitUses = count($addTraitUses)) { ksort($addTraitUses); $traitUses = array_map(function (string $use) use ($nl, $indent): string { return $indent.'use '.$use.';'.$nl; }, array_keys($addTraitUses)); if (!$hasTraitUses) { $traitUses[] = $nl; } array_splice($lines, $traitUseLine, 0, $traitUses); $write = true; } if ($numImplementors = count($addImplementors)) { ksort($addImplementors); $implements = ($hasImplements ? ', ' : ' implements ').implode(', ', array_keys($addImplementors)); $lines[$implementsLine - 1] = preg_replace('~(\s*+{?\s*+)$~', $implements.'\\1', $lines[$implementsLine - 1], 1); $write = true; } if ($write) { $this->writes[] = [$fileName, implode('', $lines)]; } } private function generateControllers(ConsoleStyle $io): void { if (!$this->credential || !$io->confirm('Generate controllers?')) { return; } if ( !class_exists(AnnotatedRouteControllerLoader::class) || !interface_exists(FormInterface::class) || !interface_exists(ValidatorInterface::class) || !class_exists(Environment::class) || !class_exists(CommandBus::class) || !interface_exists(EntityManagerInterface::class) || !class_exists(Security::class) ) { $io->note('Not all controller dependencies are met. Run `composer require annotations form validator twig simple-bus/symfony-bridge orm security`'); if (!$io->confirm('Continue anyway?')) { return; } } $usernameField = ($hasUsername = $this->hasUsername()) ? $this->credential::getUsernameField() : null; $hasPassword = $this->hasPassword(); $nsForm = trim($io->ask('Provide the form namespace', 'App\\Form\\User\\'), '\\'); $nsController = trim($io->ask('Provide the controller namespace', 'App\\Controller\\User\\'), '\\'); $templateDir = trim($io->ask('Provide the base template directory', 'user/'), '/'); $baseTemplate = ltrim($io->ask('Provide the base template file', 'base.html.twig'), '/'); $baseTemplateBlock = $io->ask('Provide the base template block name', 'body'); $hasRegistration = $hasUsername && $io->confirm('Add a registration controller?'); $hasLogin = $hasPassword && $io->confirm('Add a login and profile controller?'); $hasForgotPassword = $this->passwordReset && $io->confirm('Add a forgot and reset password controller?'); if ($hasLogin && $io->confirm('Add config/packages/security.yaml?')) { $this->writes[] = [$this->projectDir.'/config/packages/security.yaml', self::getSkeleton('security.php', [ 'fieldName' => $usernameField, ])]; } if ($hasRegistration) { $this->writes[] = [$this->getClassFileName($nsForm.'\\RegisterType'), self::getSkeleton('form/RegisterType.php', [ 'ns' => $nsForm, 'hasPassword' => $hasPassword, 'fieldName' => $usernameField, ])]; $this->writes[] = [$this->getClassFileName($nsController.'\\RegisterController'), self::getSkeleton('controller/RegisterController.php', [ 'ns' => $nsController, 'formNs' => $nsForm, 'fieldName' => $usernameField, 'template' => $template = $templateDir.'/register.html.twig', 'redirect' => $hasLogin ? '/login' : '/', ])]; $this->writes[] = [$this->getTemplateFileName($template), self::getSkeleton('template/register.html.php', [ 'base' => $baseTemplate, 'block' => $baseTemplateBlock, 'fieldName' => $usernameField, 'hasPassword' => $hasPassword, ])]; } if ($hasLogin) { $this->writes[] = [$this->getClassFileName($nsForm.'\\LoginType'), self::getSkeleton('form/LoginType.php', [ 'ns' => $nsForm, 'fieldName' => $usernameField, ])]; $this->writes[] = [$this->getClassFileName($nsController.'\\LoginController'), self::getSkeleton('controller/LoginController.php', [ 'ns' => $nsController, 'formNs' => $nsForm, 'fieldName' => $usernameField, 'template' => $templateLogin = $templateDir.'/login.html.twig', ])]; $this->writes[] = [$this->getClassFileName($nsController.'\\ProfileController'), self::getSkeleton('controller/ProfileController.php', [ 'ns' => $nsController, 'template' => $templateProfile = $templateDir.'/profile.html.twig', ])]; $this->writes[] = [$this->getTemplateFileName($templateLogin), self::getSkeleton('template/login.html.php', [ 'base' => $baseTemplate, 'block' => $baseTemplateBlock, 'fieldName' => $usernameField, 'hasForgotPassword' => $hasForgotPassword, ])]; $this->writes[] = [$this->getTemplateFileName($templateProfile), self::getSkeleton('template/profile.html.php', [ 'base' => $baseTemplate, 'block' => $baseTemplateBlock, 'fieldName' => $usernameField, ])]; } if ($hasForgotPassword) { $this->writes[] = [$this->getClassFileName($nsForm.'\\ForgotPasswordType'), self::getSkeleton('form/ForgotPasswordType.php', [ 'ns' => $nsForm, 'fieldName' => $usernameField, ])]; $this->writes[] = [$this->getClassFileName($nsForm.'\\ResetPasswordType'), self::getSkeleton('form/ResetPasswordType.php', [ 'ns' => $nsForm, ])]; $this->writes[] = [$this->getClassFileName($nsController.'\\ForgotPasswordController'), self::getSkeleton('controller/ForgotPasswordController.php', [ 'ns' => $nsController, 'formNs' => $nsForm, 'fieldName' => $usernameField, 'userClass' => $this->user->getName(), 'userShortClass' => $this->user->getShortName(), 'template' => $templateForgot = $templateDir.'/forgot_password.html.twig', ])]; $this->writes[] = [$this->getClassFileName($nsController.'\\ResetPasswordController'), self::getSkeleton('controller/ResetPasswordController.php', [ 'ns' => $nsController, 'formNs' => $nsForm, 'userClass' => $this->user->getName(), 'userShortClass' => $this->user->getShortName(), 'template' => $templateReset = $templateDir.'/reset_password.html.twig', ])]; $this->writes[] = [$this->getTemplateFileName($templateForgot), self::getSkeleton('template/forgot_password.html.php', [ 'base' => $baseTemplate, 'block' => $baseTemplateBlock, 'fieldName' => $usernameField, ])]; $this->writes[] = [$this->getTemplateFileName($templateReset), self::getSkeleton('template/reset_password.html.php', [ 'base' => $baseTemplate, 'block' => $baseTemplateBlock, 'fieldName' => $usernameField, ])]; } } private function generateConsole(ConsoleStyle $io): void { if (!$this->hasPassword()) { return; } [$contextElementFactoryNs, $contextElementFactoryShortClass] = self::splitClass($contextElementFactoryClass = 'App\\Console\\ClassContextElementFactory'); $this->writes[] = [$this->getClassFileName($contextElementFactoryClass), self::getSkeleton('service/ClassContextElementFactory.php', [ 'ns' => $contextElementFactoryNs, 'class' => $contextElementFactoryShortClass, 'userClass' => $this->user->getName(), 'userShortClass' => $this->user->getShortName(), 'credentialClass' => $this->credential, 'credentialShortClass' => self::splitClass($this->credential)[1], ])]; $this->services[] = <<set('app.console.class_context_element_factory', ${contextElementFactoryClass}::class) ->decorate(MsgPhp\\Domain\\Infra\\Console\\Context\\ClassContextElementFactoryInterface::class) ->arg('\$factory', ref('app.console.class_context_element_factory.inner')) PHP; } private static function getConstructorSignature(\ReflectionClass $class): string { if (null === $constructor = $class->getConstructor()) { return ''; } $lines = file($class->getFileName()); $offset = $constructor->getStartLine() - 1; $body = implode('', array_slice($lines, $offset, $constructor->getEndLine() - $offset)); if (preg_match('~^[^_]*+__construct\(([^\)]++)\)~i', $body, $matches)) { return $matches[1]; } return ''; } private static function getSignatureVariables(string $signature): string { preg_match_all('~(?:\.{3})?\$[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*~', $signature, $matches); return isset($matches[0][0]) ? implode(', ', $matches[0]) : ''; } private static function getSkeleton(string $path, array $vars = []) { return (function () use ($path, $vars) { extract($vars); return require dirname(__DIR__).'/Resources/skeleton/'.$path; })(); } private static function splitClass(string $class): array { $ns = 'App'; if (false !== $i = strrpos($class, '\\')) { $ns = substr($class, 0, $i); $class = substr($class, $i + 1); } return [$ns, $class]; } private function getTemplateFileName(string $path): string { return $this->projectDir.'/templates/'.$path; } private function getClassFileName(string $class): string { if ('App\\' === substr($class, 0, 4)) { $class = substr($class, 4); } return $this->projectDir.'/src/'.str_replace('\\', '/', $class).'.php'; } private function hasUsername(): bool { return $this->credential && Entity\Credential\Anonymous::class !== $this->credential; } private function hasPassword(): bool { return $this->credential && false !== strpos($this->credential, 'Password'); } } msgphp-0.4.3/src/UserBundle/MsgPhpUserBundle.php000066400000000000000000000017661327361626700216020ustar00rootroot00000000000000 */ final class MsgPhpUserBundle extends Bundle { public function boot(): void { BundleHelper::boot($this->container); } public function build(ContainerBuilder $container): void { $container->addCompilerPass(new CleanupPass(), PassConfig::TYPE_BEFORE_OPTIMIZATION, 100); BundleHelper::initDomain($container); } public function getContainerExtension(): ?ExtensionInterface { return new Extension(); } } msgphp-0.4.3/src/UserBundle/README.md000066400000000000000000000113231327361626700171470ustar00rootroot00000000000000# User bundle A new Symfony bundle for basic user management. [![Latest Stable Version](https://poser.pugx.org/msgphp/user-bundle/v/stable)](https://packagist.org/packages/msgphp/user-bundle) This package is part of the _Message driven PHP_ project. > [MsgPHP](https://msgphp.github.io/) is a project that aims to provide (common) message based domain layers for your application. It has a low development time overhead and avoids being overly opinionated. ## Installation ```bash composer require msgphp/user-bundle ``` ## Features - Symfony 3.4 / 4.0 ready - Doctrine persistence - Symfony console commands - Symfony security infrastructure - Symfony validators - Credential independent (supports e-mail, nickname, etc.) - Multiple username / credential support - Primary and secondary user e-mails - Disabled / enabled users - User roles - User attribute values ## Blog posts - [Adding user management to your Symfony application](https://medium.com/@ro0NL/adding-user-management-to-your-symfony-application-ceeefe2a2e9) - [Commanding a decoupled User entity](https://medium.com/@ro0NL/commanding-a-decoupled-user-entity-aee8723c43e5) - [Decoupling the User entity with a new Symfony User Bundle](https://medium.com/@ro0NL/decoupling-the-user-entity-with-a-new-symfony-user-bundle-7d2d5d85bdf9) - [Building a new Symfony User Bundle](https://medium.com/@ro0NL/building-a-new-symfony-user-bundle-b4fe5a9d9d80) ## Configuration ```php extension('msgphp_user', [ 'class_mapping' => [ User::class => \App\Entity\User\User::class, ], ]); }; ``` ### Feeling lazy? ```bash composer require annot form validator twig security simple-bus/symfony-bridge orm composer require maker server --dev bin/console make:user ``` And be done. ## Usage ### With [`DoctrineBundle`](https://github.com/doctrine/DoctrineBundle) Repositories from `MsgPhp\User\Infra\Doctrine\Repository\*` are registered as a service. Corresponding domain interfaces from `MsgPhp\User\Repository\*` are aliased. Minimal configuration: ```yaml # config/packages/doctrine.yaml doctrine: orm: mappings: app: dir: '%kernel.project_dir%/src/Entity' type: annotation prefix: App\Entity ``` - Requires `doctrine/orm` ### With [`SimpleBusCommandBusBundle`](https://github.com/SimpleBus/SymfonyBridge) Command handlers from `MsgPhp\User\Command\*` are registered as a service. - Requires `DoctrineBundle + doctrine/orm` ### With [`SecurityBundle`](https://github.com/symfony/security-bundle) Security infrastructure from `MsgPhp\User\Infra\Security\*` is registered as a service. In practice the security user is decoupled from your domain entity user. An approach described [here](https://stovepipe.systems/post/decoupling-your-security-user). - `MsgPhp\User\Infra\Security\SecurityUser` implementing `Symfony\Component\Security\Core\User\UserInterface` - `App\Entity\User\User` extending `MsgPhp\User\Entity\User` Minimal configuration: ```yaml # config/packages/security.yaml security: encoders: MsgPhp\User\Infra\Security\SecurityUser: bcrypt providers: msgphp_user: { id: MsgPhp\User\Infra\Security\SecurityUserProvider } firewalls: main: provider: msgphp_user anonymous: ~ ``` - Requires `DoctrineBundle + doctrine/orm` - Suggests `SensioFrameworkExtraBundle` to enable the parameter converter ### With [`symfony/console`](https://github.com/symfony/console) Console commands from `MsgPhp\User\Infra\Console\Command\*` are registered as a service. - Requires `DoctrineBundle + doctrine/orm` - Requires `SimpleBusCommandBusBundle` ### With [`symfony/form`](https://github.com/symfony/form) Form types from `MsgPhp\User\Infra\Form\Type\*` are registered as a service. ### With [`symfony/validator`](https://github.com/symfony/validator) Validators from `MsgPhp\User\Infra\Validator\*` are registered as a service. - Requires `DoctrineBundle + doctrine/orm` ## Documentation - Read the [main documentation](https://msgphp.github.io/docs/) - Browse the [API documentation](https://msgphp.github.io/api/MsgPhp/UserBundle.html) - Try the Symfony [demo application](https://github.com/msgphp/symfony-demo-app) - Get support on [Symfony's Slack `#msgphp` channel](https://symfony.com/slack-invite) or [raise an issue](https://github.com/msgphp/msgphp/issues/new) ## Contributing This repository is **READ ONLY**. Issues and pull requests should be submitted in the [main development repository](https://github.com/msgphp/msgphp). msgphp-0.4.3/src/UserBundle/Resources/000077500000000000000000000000001327361626700176425ustar00rootroot00000000000000msgphp-0.4.3/src/UserBundle/Resources/config/000077500000000000000000000000001327361626700211075ustar00rootroot00000000000000msgphp-0.4.3/src/UserBundle/Resources/config/console.php000066400000000000000000000007641327361626700232710ustar00rootroot00000000000000services() ->defaults() ->autowire() ->autoconfigure() ->private() ->load('MsgPhp\\User\\Infra\\Console\\Command\\', Configuration::getPackageDir().'/Infra/Console/Command/*Command.php') ; }; msgphp-0.4.3/src/UserBundle/Resources/config/doctrine.php000066400000000000000000000015201327361626700234250ustar00rootroot00000000000000services() ->defaults() ->autowire() ->private() ->load('MsgPhp\\User\\Infra\\Doctrine\\Repository\\', Configuration::getPackageDir().'/Infra/Doctrine/Repository/*Repository.php') ->set(Doctrine\Event\UsernameListener::class) ->tag('doctrine.orm.entity_listener') ->tag('doctrine.event_listener', ['event' => DoctrineOrmEvents::loadClassMetadata]) ->tag('doctrine.event_listener', ['event' => DoctrineOrmEvents::postFlush]) ; }; msgphp-0.4.3/src/UserBundle/Resources/config/form.php000066400000000000000000000006121327361626700225620ustar00rootroot00000000000000services() ->defaults() ->autowire() ->autoconfigure() ->private() ->set(Form\Type\HashedPasswordType::class) ; }; msgphp-0.4.3/src/UserBundle/Resources/config/message.php000066400000000000000000000007741327361626700232540ustar00rootroot00000000000000services() ->defaults() ->autowire() ->private() ->load('MsgPhp\\User\\Command\\Handler\\', Configuration::getPackageDir().'/Command/Handler/*Handler.php') ->tag('msgphp.domain.command_handler') ; }; msgphp-0.4.3/src/UserBundle/Resources/config/security.php000066400000000000000000000031761327361626700234760ustar00rootroot00000000000000services() ->defaults() ->autowire() ->private() ->set(Security\PasswordHashing::class) ->args([ inline(SymfonyPasswordEncoderInterface::class) ->factory([ref('security.encoder_factory'), 'getEncoder']) ->args([Security\SecurityUser::class]), ]) ->alias(PasswordHashingInterface::class, Security\PasswordHashing::class) ->set(Security\SecurityUserProvider::class) ->set(Security\UserArgumentValueResolver::class) ->tag('controller.argument_value_resolver') ; if (interface_exists(ParamConverterInterface::class)) { $services->set(Security\UserParamConverter::class) ->tag('request.param_converter', ['converter' => Security\UserParamConverter::NAME]); } if (interface_exists(UserProviderWithPayloadSupportsInterface::class)) { $services->set(Security\Jwt\SecurityUserProvider::class); } }; msgphp-0.4.3/src/UserBundle/Resources/config/services.php000066400000000000000000000015521327361626700234460ustar00rootroot00000000000000services() ->defaults() ->autowire() ->autoconfigure() ->private() ->set(PasswordHashing::class) ->alias(PasswordHashingInterface::class, PasswordHashing::class) ; if (interface_exists(MakerInterface::class)) { $services->set(Maker\UserMaker::class, Maker\UserMaker::class) ->arg('$classMapping', '%msgphp.domain.class_mapping%') ->arg('$projectDir', '%kernel.project_dir%') ->tag('maker.command'); } }; msgphp-0.4.3/src/UserBundle/Resources/config/twig.php000066400000000000000000000006011327361626700225670ustar00rootroot00000000000000services() ->defaults() ->autowire() ->autoconfigure() ->private() ->set(Twig\GlobalVariable::class) ; }; msgphp-0.4.3/src/UserBundle/Resources/config/validator.php000066400000000000000000000007161327361626700236110ustar00rootroot00000000000000services() ->defaults() ->autowire() ->autoconfigure() ->private() ->set(Validator\ExistingUsernameValidator::class) ->set(Validator\UniqueUsernameValidator::class) ; }; msgphp-0.4.3/src/UserBundle/Resources/skeleton/000077500000000000000000000000001327361626700214665ustar00rootroot00000000000000msgphp-0.4.3/src/UserBundle/Resources/skeleton/config.php000066400000000000000000000016061327361626700234470ustar00rootroot00000000000000extension('msgphp_user', ${config}); PHP; } foreach ($services as $service) { $servicesConfig .= $sep.' '.str_replace("\n", "\n ", $service); $sep = "\n\n"; } if ($servicesConfig) { if ($extensionConfig) { $extensionConfig .= "\n\n"; } $servicesConfig = <<services() ->defaults() ->private() ->autoconfigure() ->autowire() ${servicesConfig} ; PHP; } return <<createNamed('', ForgotPasswordType::class); \$form->handleRequest(\$request); if (\$form->isSubmitted() && \$form->isValid()) { \$user = \$em->getRepository(${userShortClass}::class)->findOneBy(['credential.${fieldName}' => \$form->getData()['${fieldName}']]); \$bus->handle(new RequestUserPasswordCommand(\$user->getId())); \$flashBag->add('success', 'You\'re password is requested.'); return new RedirectResponse('/login'); } return new Response(\$twig->render('${template}', [ 'form' => \$form->createView(), ])); } } PHP; msgphp-0.4.3/src/UserBundle/Resources/skeleton/controller/LoginController.php000066400000000000000000000024051327361626700274770ustar00rootroot00000000000000createNamed('', LoginType::class, [ '${fieldName}' => \$authenticationUtils->getLastUsername(), ]); if (null !== \$error = \$authenticationUtils->getLastAuthenticationError(true)) { \$form->addError(new FormError(\$error->getMessage(), \$error->getMessageKey(), \$error->getMessageData())); } return new Response(\$twig->render('${template}', [ 'form' => \$form->createView(), ])); } } PHP; msgphp-0.4.3/src/UserBundle/Resources/skeleton/controller/ProfileController.php000066400000000000000000000010201327361626700300170ustar00rootroot00000000000000render('${template}')); } } PHP; msgphp-0.4.3/src/UserBundle/Resources/skeleton/controller/RegisterController.php000066400000000000000000000027641327361626700302230ustar00rootroot00000000000000createNamed('', RegisterType::class); \$form->handleRequest(\$request); if (\$form->isSubmitted() && \$form->isValid()) { \$bus->handle(new CreateUserCommand(\$form->getData())); \$flashBag->add('success', 'You\'re successfully registered.'); return new RedirectResponse('${redirect}'); } return new Response(\$twig->render('${template}', [ 'form' => \$form->createView(), ])); } } PHP; msgphp-0.4.3/src/UserBundle/Resources/skeleton/controller/ResetPasswordController.php000066400000000000000000000040031327361626700312300ustar00rootroot00000000000000getRepository(${userShortClass}::class)->findOneBy(['passwordResetToken' => \$token]); if (!\$user instanceof ${userShortClass}) { throw new NotFoundHttpException(); } \$form = \$formFactory->createNamed('', ResetPasswordType::class); \$form->handleRequest(\$request); if (\$form->isSubmitted() && \$form->isValid()) { \$bus->handle(new ChangeUserCredentialCommand(\$user->getId(), ['password' => \$form->getData()['password']])); \$flashBag->add('success', 'You\'re password is changed.'); return new RedirectResponse('/login'); } return new Response(\$twig->render('${template}', [ 'form' => \$form->createView(), ])); } } PHP; msgphp-0.4.3/src/UserBundle/Resources/skeleton/entity/000077500000000000000000000000001327361626700230025ustar00rootroot00000000000000msgphp-0.4.3/src/UserBundle/Resources/skeleton/entity/Role.php000066400000000000000000000007331327361626700244170ustar00rootroot00000000000000name = \$name; } public function getName(): string { return \$this->name; } } PHP; msgphp-0.4.3/src/UserBundle/Resources/skeleton/entity/UserRole.php000066400000000000000000000005571327361626700252620ustar00rootroot00000000000000add('${fieldName}', ${fieldType}::class, [ 'constraints' => [${constraints}], ]); } } PHP; msgphp-0.4.3/src/UserBundle/Resources/skeleton/form/LoginType.php000066400000000000000000000013571327361626700250620ustar00rootroot00000000000000add('${fieldName}', ${fieldType}::class); \$builder->add('password', PasswordType::class); } } PHP; msgphp-0.4.3/src/UserBundle/Resources/skeleton/form/RegisterType.php000066400000000000000000000027221327361626700255730ustar00rootroot00000000000000add('${fieldName}', ${fieldType}::class, [ 'constraints' => [${constraints}], ]); PHP; if ($hasPassword) { $uses[] = 'use MsgPhp\\User\\Infra\\Form\\Type\\HashedPasswordType;'; $fields .= <<add('password', HashedPasswordType::class, [ 'password_confirm' => true, 'password_options' => ['constraints' => new NotBlank()], ]); PHP; } sort($uses); $uses = implode("\n", $uses); return <<add('password', HashedPasswordType::class, [ 'password_confirm' => true, 'password_options' => ['constraints' => new NotBlank()], ]); } } PHP; msgphp-0.4.3/src/UserBundle/Resources/skeleton/security.php000066400000000000000000000024401327361626700240460ustar00rootroot00000000000000label = 'E-mail'; break; PHP; } if (false !== strpos($credentialClass, 'Password')) { $uses[] = 'use MsgPhp\User\Password\PasswordHashingInterface;'; $constructor = <<factory = \$factory; \$this->passwordHashing = \$passwordHashing; } PHP; $cases[] = <<hide() ->generator(function (): string { return bin2hex(random_bytes(8)); }) ->normalizer(function (string \$value): string { return \$this->passwordHashing->hash(\$value); }); } break; PHP; } else { $constructor = <<factory = \$factory; } PHP; } $switch = ''; if ($cases) { $switch = "\n\n switch (\$argument) {\n".implode("\n", $cases)."\n }"; } sort($uses); $uses = implode("\n", $uses); return <<factory->getElement(\$class, \$method, \$argument);${switch} return \$element; } } PHP; msgphp-0.4.3/src/UserBundle/Resources/skeleton/service/UserRolesProvider.php000066400000000000000000000012531327361626700272760ustar00rootroot00000000000000getRoles()->map(function (UserRole \$userRole) { return \$userRole->getRoleName(); })); } } PHP; msgphp-0.4.3/src/UserBundle/Resources/skeleton/template/000077500000000000000000000000001327361626700233015ustar00rootroot00000000000000msgphp-0.4.3/src/UserBundle/Resources/skeleton/template/forgot_password.html.php000066400000000000000000000005551327361626700302040ustar00rootroot00000000000000Forgot Password {{ form_start(form) }} {{ form_errors(form) }} {{ form_row(form.${fieldName}) }}
{{ form_end(form) }} {% endblock %} TWIG; msgphp-0.4.3/src/UserBundle/Resources/skeleton/template/login.html.php000066400000000000000000000011151327361626700260630ustar00rootroot00000000000000Forgot password?

TWIG; } else { $forgotPasswordLink = ''; } return <<Login {{ form_start(form) }} {{ form_errors(form) }} {{ form_row(form.${fieldName}) }} {{ form_row(form.password) }}
${forgotPasswordLink}
{{ form_end(form) }} {% endblock %} TWIG; msgphp-0.4.3/src/UserBundle/Resources/skeleton/template/profile.html.php000066400000000000000000000003251327361626700264150ustar00rootroot00000000000000Your Profile

Logged in as: {{ msgphp_user.user.${fieldName} }}

{% endblock %} TWIG; msgphp-0.4.3/src/UserBundle/Resources/skeleton/template/register.html.php000066400000000000000000000010261327361626700266000ustar00rootroot00000000000000Register {{ form_start(form) }} {{ form_errors(form) }} ${fields}
{{ form_end(form) }} {% endblock %} TWIG; msgphp-0.4.3/src/UserBundle/Resources/skeleton/template/reset_password.html.php000066400000000000000000000006451327361626700300260ustar00rootroot00000000000000Reset Password {{ form_start(form) }} {{ form_errors(form) }} {{ form_row(form.password.password) }} {{ form_row(form.password.confirmation) }}
{{ form_end(form) }} {% endblock %} TWIG; msgphp-0.4.3/src/UserBundle/Twig/000077500000000000000000000000001327361626700166025ustar00rootroot00000000000000msgphp-0.4.3/src/UserBundle/Twig/GlobalVariable.php000066400000000000000000000050011327361626700221550ustar00rootroot00000000000000 * * @internal */ final class GlobalVariable implements ServiceSubscriberInterface { public const NAME = 'msgphp_user'; private $container; public function __construct(ContainerInterface $container) { $this->container = $container; } public function getCurrent(): User { return $this->getUserRepository()->find($this->getId()); } public function getId(): UserIdInterface { $token = $this->getTokenStorage()->getToken(); if (null === $token) { throw new \LogicException('User not authenticated.'); } $user = $token->getUser(); if (!$user instanceof SecurityUser) { throw new \LogicException('User not authenticated.'); } /** @var UserIdInterface $id */ $id = $this->getObjectFactory()->identify(User::class, $user->getUsername()); return $id; } public function isUserType(User $user, string $class): bool { return $user instanceof $class; } public static function getSubscribedServices(): array { return [ EntityAwareFactoryInterface::class, '?'.TokenStorageInterface::class, '?'.UserRepositoryInterface::class, ]; } private function getObjectFactory(): EntityAwareFactoryInterface { return $this->container->get(EntityAwareFactoryInterface::class); } private function getTokenStorage(): TokenStorageInterface { if (!$this->container->has(TokenStorageInterface::class)) { throw new \LogicException('Token storage not available.'); } return $this->container->get(TokenStorageInterface::class); } private function getUserRepository(): UserRepositoryInterface { if (!$this->container->has(UserRepositoryInterface::class)) { throw new \LogicException('User repository not available.'); } return $this->container->get(UserRepositoryInterface::class); } } msgphp-0.4.3/src/UserBundle/composer.json000066400000000000000000000027251327361626700204200ustar00rootroot00000000000000{ "name": "msgphp/user-bundle", "type": "symfony-bundle", "license": "MIT", "description": "Basic user management (the `User` domain)", "keywords": ["user", "security"], "authors": [ { "name": "Roland Franssen", "email": "franssen.roland@gmail.com" } ], "minimum-stability": "dev", "autoload": { "psr-4": { "MsgPhp\\UserBundle\\": "" }, "exclude-from-classmap": ["/Tests/"] }, "require": { "msgphp/user": "^0.4|^1.0", "symfony/config": "^3.4|^4.0", "symfony/dependency-injection": "^3.4|^4.0", "symfony/http-kernel": "^3.4|^4.0" }, "require-dev": { "doctrine/doctrine-bundle": "^1.8", "doctrine/orm": "^2.6", "lexik/jwt-authentication-bundle": "^2.5@dev", "simple-bus/symfony-bridge": "^5.1", "symfony/console": "^3.4|^4.0", "symfony/form": "^3.4|^4.0", "symfony/phpunit-bridge": "^3.4|^4.0", "symfony/security-bundle": "^3.4|^4.0", "symfony/twig-bundle": "^3.4|^4.0", "symfony/validator": "^3.4|^4.0", "symfony/var-dumper": "^3.4|^4.0" }, "suggest": { "msgphp/eav-bundle": "To enable user attribute values" }, "config": { "preferred-install": { "*": "dist" }, "sort-packages": true }, "extra": { "branch-alias": { "dev-master": "1.0-dev" } } }