pax_global_header00006660000000000000000000000064133553650240014520gustar00rootroot0000000000000052 comment=f34d397d09f74c6350786b32399f3bcf8314578a msgphp-0.7.0/000077500000000000000000000000001335536502400130225ustar00rootroot00000000000000msgphp-0.7.0/.codecov.yml000066400000000000000000000004261335536502400152470ustar00rootroot00000000000000comment: 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.7.0/.editorconfig000066400000000000000000000001201335536502400154700ustar00rootroot00000000000000root = true [*] end_of_line = LF [*.php] indent_style = space indent_size = 4 msgphp-0.7.0/.env.dist000066400000000000000000000000161335536502400145520ustar00rootroot00000000000000GITHUB_TOKEN= msgphp-0.7.0/.github/000077500000000000000000000000001335536502400143625ustar00rootroot00000000000000msgphp-0.7.0/.github/ISSUE_TEMPLATE.md000066400000000000000000000001411335536502400170630ustar00rootroot00000000000000 msgphp-0.7.0/.github/PULL_REQUEST_TEMPLATE.md000066400000000000000000000001461335536502400201640ustar00rootroot00000000000000 msgphp-0.7.0/.gitignore000066400000000000000000000000751335536502400150140ustar00rootroot00000000000000/.env /var .php_cs.cache composer.lock composer.phar vendor/ msgphp-0.7.0/.lando.yml000066400000000000000000000005601335536502400147210ustar00rootroot00000000000000name: 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.7.0/.php_cs.dist000066400000000000000000000013771335536502400152510ustar00rootroot00000000000000 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'], 'php_unit_test_case_static_method_calls' => ['call_type' => 'self'], ]; 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.7.0/.sami.dist000066400000000000000000000011551335536502400147200ustar00rootroot00000000000000files() ->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.7.0/.travis.yml000066400000000000000000000023631335536502400151370ustar00rootroot00000000000000dist: trusty sudo: false language: php notifications: email: false branches: only: - master - /^\d\.\d$/ php: 7.2 jobs: include: - stage: Unit-tests env: CC=true - env: DEPS=low - php: 7.1 - stage: Code-quality install: true script: - bin/cs - bin/sa before_install: - if [[ $CC = true && $TRAVIS_PULL_REQUEST != false ]] ; then unset CC ; fi - if [[ $CC != true ]] ; then phpenv config-rm xdebug.ini || true ; fi - source .travis/tfold install: - | COMPOSER_ARGS="--no-progress --prefer-dist --no-interaction --no-suggest" PHPUNIT_ARGS="" if [[ $DEPS = low ]] ; then COMPOSER_ARGS="${COMPOSER_ARGS} --prefer-stable --prefer-lowest" ; fi if [[ $CC = true ]] ; then PHPUNIT_ARGS="${PHPUNIT_ASRGS} --coverage-clover=coverage.xml" ; fi - travis_retry .travis/packager HEAD^ $(find src/*/composer.json -type f -printf '%h\n') - travis_retry bin/composer update $COMPOSER_ARGS - travis_retry bin/phpunit install script: - bin/phpunit $PHPUNIT_ARGS after_success: - if [[ $CC = true ]] ; then bash <(curl -s https://codecov.io/bash) ; fi before_cache: - rm -rf $HOME/.composer/cache/files/msgphp cache: directories: - $HOME/.composer/cache - var/cache/ msgphp-0.7.0/.travis/000077500000000000000000000000001335536502400144105ustar00rootroot00000000000000msgphp-0.7.0/.travis/packager000077500000000000000000000062121335536502400161140ustar00rootroot00000000000000#!/usr/bin/env php $_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.7.0/.travis/tfold000077500000000000000000000020461335536502400154500ustar00rootroot00000000000000#!/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.7.0/CONTRIBUTING.md000066400000000000000000000017141335536502400152560ustar00rootroot00000000000000# 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 ``` ## Using [Lando](https://docs.devwithlando.io) ```bash lando bash 'bin/ ' ``` msgphp-0.7.0/LICENSE000066400000000000000000000020601335536502400140250ustar00rootroot00000000000000MIT 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.7.0/README.md000066400000000000000000000053341335536502400143060ustar00rootroot00000000000000# 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 - [Domain-driven-design: Projections in practice with API Platform and Elasticsearch](https://medium.com/@ro0NL/domain-driven-design-projections-in-practice-with-api-platform-and-elasticsearch-c785ed6d660b) - [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.7.0/UPGRADE-0.2.md000066400000000000000000000014121335536502400147260ustar00rootroot00000000000000# 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.7.0/UPGRADE-0.3.md000066400000000000000000000006201335536502400147270ustar00rootroot00000000000000# 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.7.0/UPGRADE-0.4.md000066400000000000000000000016231335536502400147340ustar00rootroot00000000000000# 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.7.0/UPGRADE-0.5.md000066400000000000000000000020531335536502400147330ustar00rootroot00000000000000# UPGRADE FROM 0.4 to 0.5 ## Domain - Renamed `DomainProjectionInterface` to `ProjectionInterface` - Renamed `DomainProjectionDocument` to `ProjectionDocument` - Renamed `DomainProjectionDocumentProvider` to `ProjectionDocumentProvider` - Renamed `DomainProjectionDocumentTransformerInterface` to `ProjectionDocumentTransformerInterface` - Updated `DomainProjectionRepositoryInterface::findAll(): DomainProjectionInterface[]` to `findAll(): ProjectionDocument[]` - Updated `DomainProjectionRepositoryInterface::find(): ?DomainProjectionInterface` to `find(): ?ProjectionDocument` - Renamed `DomainProjectionRepositoryInterface` to `ProjectionRepositoryInterface` - Renamed `DomainProjectionSynchronization` to `ProjectionSynchronization` - Renamed `DomainProjectionTypeRegistryInterface` to `ProjectionTypeRegistryInterface` - Added default projection messages (`Command\` and `Event\`) ## UserBundle - Updated `make:user` to generate code using Symfony Messenger instead of SimpleBus - Disabled legacy credentials in `make:user` (`Email/NicknameSaltedPassword`) msgphp-0.7.0/UPGRADE-0.6.md000066400000000000000000000012651335536502400147400ustar00rootroot00000000000000# UPGRADE FROM 0.5 to 0.6 ## Domain - Updated `ProjectionRepositoryInterface::findAll(): iterable` to `findAll(): PaginatedDomainCollectionInterface` - Added `PaginatedDomainCollection` - Added `DomainCollectionFactory::createFromCallable()` ## Eav - Marked `AttributeValue::getChecksum()` static, requiring `$value` as 1st argument - Finalized `AttributeValue::get/changeValue()` ## User - Added `SecurityUser::getUserId(): UserIdInterface` ## UserBundle - Renamed default Twig variable Before: ``` {{ msgphp_user.id }} ``` After: ``` {{ msgphp_user.currentId }} ``` - Changed default value for `msgphp_user.username_lookup.N.mapped_by` to `null` msgphp-0.7.0/UPGRADE-0.7.md000066400000000000000000000017661335536502400147470ustar00rootroot00000000000000# UPGRADE FROM 0.6 to 0.7 ## User - Marked `Username` abstract - Renamed CLI command `user:synchronize:usernames` to `user:synchronize-usernames` - Replaced `MsgPhp\User\Infra\Security\UserRolesProviderInterface` by `MsgPhp\User\Role\RoleProviderInterface` ## UserBundle - Replaced generated `App\Security\UserRolesProvider` with config: ```yaml msgphp_user: # ... role_providers: #- default: [ROLE_USER] - MsgPhp\User\Role\UserRoleProvider ``` - Create and configure the `Username` entity in case `msgphp_php.username_lookup` is configured ```yaml msgphp_user: class_mapping: MsgPhp\User\Entity\Username: App\Entity\User\Username username_lookup: - # ... ``` ```php /dev/null 2>&1 if [[ $? -eq 0 ]] ; then lando bash "bin/sami update .sami.dist" else bin/sami update .sami.dist fi 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.7.0/bin/clean000077500000000000000000000001351335536502400146010ustar00rootroot00000000000000#!/usr/bin/env bash rm -rf composer.lock var/ vendor/ bin/each rm -rf composer.lock vendor/ msgphp-0.7.0/bin/compile-docrefs000077500000000000000000000110511335536502400165710ustar00rootroot00000000000000#!/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): string { return 'MsgPhp\\'.str_replace('/', '\\', substr($file, 4, -4)); }, 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')), 'repositories' => array_map(function (string $file): string { return 'MsgPhp\\'.str_replace('/', '\\', substr($file, 4, -4)); }, glob(dirname($file).'/Repository/*RepositoryInterface.php')), 'commands' => array_map(function (string $file): string { return 'MsgPhp\\'.str_replace('/', '\\', substr($file, 4, -4)); }, glob(dirname($file).'/Command/*Command.php')), 'events' => array_filter(array_map(function (string $file): string { return 'MsgPhp\\'.str_replace('/', '\\', substr($file, 4, -4)); }, glob(dirname($file).'/Event/*Event.php')), function (string $class): bool { return !is_subclass_of($class, DomainEventInterface::class); }), 'domain_events' => array_filter(array_map(function (string $file): string { return 'MsgPhp\\'.str_replace('/', '\\', substr($file, 4, -4)); }, glob(dirname($file).'/Event/{*,Domain/*}Event.php', \GLOB_BRACE)), function (string $class): bool { return is_subclass_of($class, DomainEventInterface::class); }), ]; } 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.7.0/bin/composer000077500000000000000000000000561335536502400153500ustar00rootroot00000000000000#!/usr/bin/env bash bin/each composer "${@}" msgphp-0.7.0/bin/create-project000077500000000000000000000025671335536502400164410ustar00rootroot00000000000000#!/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.7.0/bin/cs000077500000000000000000000006171335536502400141310ustar00rootroot00000000000000#!/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.7.0/bin/each000077500000000000000000000007741335536502400144300ustar00rootroot00000000000000#!/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.7.0/bin/mkdocs000077500000000000000000000002141335536502400147750ustar00rootroot00000000000000#!/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.7.0/bin/phpunit000077500000000000000000000001011335536502400151770ustar00rootroot00000000000000#!/usr/bin/env bash bin/each ../../bin/phpunit-package . "${@}" msgphp-0.7.0/bin/phpunit-package000077500000000000000000000020661335536502400166040ustar00rootroot00000000000000#!/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="$(cd "$1" && pwd)" else PACKAGE_DIR="${BASE_DIR}/src/$(echo "$1" | sed -r 's/(^|-)(\w)/\U\2/g')" fi shift; BIN="vendor/bin/simple-phpunit" CMD="SYMFONY_PHPUNIT_VERSION=7.3 ${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 [[ $? -ne 0 ]] ; then composer update --prefer-dist --quiet --working-dir="${BASE_DIR}" [[ $? -ne 0 ]] && exit 1 fi composer link "${PACKAGE_DIR}" --working-dir="${BASE_DIR}" [[ $? -ne 0 ]] && exit 1 fi pushd "${PACKAGE_DIR}" &> /dev/null bash -xc "${CMD}" 2>&1 [[ $? -ne 0 ]] && exit 1 popd &> /dev/null msgphp-0.7.0/bin/pr000077500000000000000000000031041335536502400141370ustar00rootroot00000000000000#!/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 echo "Branch \"${BRANCH}\" already exists" exit 1 fi 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 checkout -b "${BRANCH}" "${BRANCH}/${UPSTREAM_BRANCH}" msgphp-0.7.0/bin/sa000077500000000000000000000006011335536502400141200ustar00rootroot00000000000000#!/usr/bin/env bash if [[ $# -eq 0 ]] ; then DIR="src/ tests/fixtures/sa" 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 ${@} ${DIR}" if [[ ! -f $BIN ]] ; then composer update --prefer-dist --quiet [[ $? -ne 0 ]] && exit 1 fi bash -xc "${CMD}" 2>&1 msgphp-0.7.0/bin/sami000077500000000000000000000002751335536502400144550ustar00rootroot00000000000000#!/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.7.0/bin/smoke-test000077500000000000000000000005701335536502400156150ustar00rootroot00000000000000#!/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.7.0/bin/subtree-split000077500000000000000000000030461335536502400163250ustar00rootroot00000000000000#!/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.7.0/composer.json000066400000000000000000000014131335536502400155430ustar00rootroot00000000000000{ "description": "Composer configuration for bulk CI testing of packages", "require-dev": { "wikimedia/composer-merge-plugin": "^1.4", "friendsofphp/php-cs-fixer": "^2.13", "phpstan/phpstan": "^0.10", "phpstan/phpstan-phpunit": "^0.10", "phpunit/phpunit": "^7.3", "ro0nl/link": "^1.0", "twig/twig": "^2.5" }, "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.7.0/docs/000077500000000000000000000000001335536502400137525ustar00rootroot00000000000000msgphp-0.7.0/docs/.refs/000077500000000000000000000000001335536502400147675ustar00rootroot00000000000000msgphp-0.7.0/docs/.refs/available-bundles.php000066400000000000000000000002441335536502400210520ustar00rootroot00000000000000name][$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.7.0/docs/.refs/domain-events.php000066400000000000000000000003601335536502400202500ustar00rootroot00000000000000 {% endblock %} msgphp-0.7.0/docs/.theme/style.css000066400000000000000000000006341335536502400170070ustar00rootroot00000000000000.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.7.0/docs/code-conventions.md000066400000000000000000000034001335536502400175460ustar00rootroot00000000000000# 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 A bundle provides the following configuration nodes by default: ### `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. See also [`id_type_mapping`](#id_type_mapping). ```yaml msgphp_: default_id_type: integer ``` ### `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\SomeDomain\Command\SomeCommand: true MsgPhp\SomeDomain\Command\SomeOtherCommand: false ``` ## Basic Configuration Example Given a bundle provides the following domain identifiers: - `MsgPhp\SomeDomain\FooIdInterface` - `MsgPhp\SomeDomain\BarIdInterface` - `MsgPhp\SomeDomain\BazIdInterface` ```yaml msgphp_: default_id_type: uuid id_type_mapping: MsgPhp\SomeDomain\FooIdInterface: integer # implied: # MsgPhp\SomeDomain\BarIdInterface: uuid # MsgPhp\SomeDomain\BazIdInterface: uuid class_mapping: MsgPhp\SomeDomain\BarIdInterface: App\MyBarUuid # implied: # MsgPhp\SomeDomain\FooIdInterface: MsgPhp\SomeDomain\FooId # MsgPhp\SomeDomain\BazIdInterface: MsgPhp\SomeDomain\Infra\Uuid\BazId ``` !!! info See also the [demo application configuration] [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 application 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.7.0/docs/cookbook/configuring-a-message-bus.md000066400000000000000000000047101335536502400230450ustar00rootroot00000000000000# Configuring A Message Bus To be able to dispatch the default [messages](../reference/messages.md) a [message bus](../message-driven/message-bus.md) must be configured. ## Using [Symfony Messenger](../infrastructure/symfony-messenger.md) ### Installation ```bash composer install symfony/messenger # with Symfony Flex composer install messenger ``` ### Configuration See the Messenger [recipe configuration] for the minimal configuration to put in `config/packages/messenger.yaml`. !!! info The configuration is automatically added with Symfony Flex Configure a command- and event bus: ```yaml # config/packages/messenger.yaml framework: messenger: # ... default_bus: command_bus buses: command_bus: middleware: - msgphp.messenger.console_message_receiver event_bus: middleware: - msgphp.messenger.console_message_receiver - allow_no_handler ``` By default MsgPHP uses the bus configured under `framework.messenger.default_bus`. You can override its alias services to use any other bus: ```yaml # config/services.yaml services: # ... msgphp.messenger.command_bus: '@command_bus' msgphp.messenger.event_bus: '@event_bus' ``` ## Using [SimpleBus](../infrastructure/simple-bus.md) ### Installation ```bash composer install simple-bus/symfony-bridge ``` ### Configuration Enable the bundles: ```php ['all' => true], SimpleBus\SymfonyBridge\SimpleBusEventBusBundle::class => ['all' => true], ]; ``` By default MsgPHP uses the `simple_bus.command_bus` and `simple_bus.event_bus` services. You can override its alias services to use any other bus: ```yaml # config/services.yaml services: # ... msgphp.simple_bus.command_bus: '@simple_bus.command_bus' msgphp.simple_bus.event_bus: '@simple_bus.event_bus' ``` ## Using A Custom Bus To use a custom [message bus](../message-driven/message-bus.md) implementation you can override its main alias service: ```yaml # config/services.yaml services: # ... MsgPhp\Domain\Message\DomainMessageBusInterface: '@my_bus' ``` !!! info The implementation must be capable to dispatch both command- and event messages [recipe configuration]: https://github.com/symfony/recipes/blob/master/symfony/messenger/4.1/config/packages/messenger.yaml msgphp-0.7.0/docs/cookbook/configuring-doctrine-orm.md000066400000000000000000000115731335536502400230230ustar00rootroot00000000000000# 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 # with 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 with Symfony Flex By default MsgPHP uses the `doctrine.orm.entity_manager` service. You can override its alias service to use any other entity manager: ```yaml # config/services.yaml services: # ... msgphp.doctrine.entity_manager: '@doctrine.orm.some_other_entity_manager' ``` ## 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. When using a entity field / feature trait its default ORM mapping is configured automatically. !!! info With 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.7.0/docs/ddd/000077500000000000000000000000001335536502400145055ustar00rootroot00000000000000msgphp-0.7.0/docs/ddd/collections.md000066400000000000000000000101061335536502400173430ustar00rootroot00000000000000# 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`. ## Pagination API A collection that is part of a paginated result set is bound to `MsgPhp\Domain\PaginatedDomainCollectionInterface`. Its purpose is to expose the current pagination. ### Extends - [`DomainCollectionInterface`](#collections) --- ### `getOffset(): float` Get the current page offset. --- ### `getLimit(): float` Get the current page limit (e.g. items per page). --- ### `getCurrentPage(): float` Get the current page number. --- ### `getLastPage(): float` Get the last page number. --- ### `getTotalCount(): float` Get the total no. of items in the full result set. !!! note `count()` should return the no. of items on the current page ## 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\PaginatedDomainCollection` A first class citizen paginated domain collection to transform any collection into a paginated collection. - `__construct(iterable $elements, float $offset = .0, float $limit = .0, float $count = null, float $totalCount = null)` - `$elements`: The elements this collection contains ### `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.7.0/docs/ddd/entities.md000066400000000000000000000023101335536502400166470ustar00rootroot00000000000000# 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 ## 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.7.0/docs/ddd/factory/000077500000000000000000000000001335536502400161545ustar00rootroot00000000000000msgphp-0.7.0/docs/ddd/factory/entity-aware.md000066400000000000000000000046411335536502400211140ustar00rootroot00000000000000# 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.7.0/docs/ddd/factory/object.md000066400000000000000000000067731335536502400177610ustar00rootroot00000000000000# 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.7.0/docs/ddd/factory/static.md000066400000000000000000000036601335536502400177720ustar00rootroot00000000000000# 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.7.0/docs/ddd/identities.md000066400000000000000000000076471335536502400172060ustar00rootroot00000000000000# 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 identity in case the identity is composed from 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.7.0/docs/ddd/identity-mapping.md000066400000000000000000000036621335536502400203200ustar00rootroot00000000000000# 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.7.0/docs/ddd/repositories.md000066400000000000000000000071401335536502400175600ustar00rootroot00000000000000# 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). !!! note See the [reference](../reference/repositories.md) page for all available repositories provided per domain ## 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.7.0/docs/event-sourcing/000077500000000000000000000000001335536502400167225ustar00rootroot00000000000000msgphp-0.7.0/docs/event-sourcing/event-handlers.md000066400000000000000000000035441335536502400221710ustar00rootroot00000000000000# 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, or privately within the implementation. 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. #### Basic example ```php newValue = $value; } } class MyEntity implements DomainEventHandlerInterface { use DomainEventHandlerTrait; public $value; private function handleMyDomainEvent(MyDomainEvent $event): bool { if ($this->value === $event->newValue) { return false; } $this->value = $event->newValue; return true; } } // --- USAGE --- $entity = new MyEntity(); if ($entity->handleEvent(new MyDomainEvent('new value'))) { // do something } ``` msgphp-0.7.0/docs/event-sourcing/events.md000066400000000000000000000015141335536502400205510ustar00rootroot00000000000000# Events A domain event is bound to `MsgPhp\Domain\Event\DomainEventInterface`. Its purpose is to represent any action that can _happen_ regarding the domain. When handled it might lead to an application state change. !!! note See the [reference](../reference/domain-events.md) page for all available events provided per domain ## 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.7.0/docs/index.md000066400000000000000000000003471335536502400154070ustar00rootroot00000000000000# 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. msgphp-0.7.0/docs/infrastructure/000077500000000000000000000000001335536502400170325ustar00rootroot00000000000000msgphp-0.7.0/docs/infrastructure/api-platform.md000066400000000000000000000031361335536502400217520ustar00rootroot00000000000000# API Platform An overview of available infrastructural code when using [API Platform]. - Requires [api-platform/core] ## Projection Data Provider When working with [projections](../projection/models.md) an [API Data Provider] is provided by `MsgPhp\Domain\Infra\ApiPlatform\ProjectionDataProvider`. 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' services: # .. . MsgPhp\Domain\Infra\ApiPlatform\ProjectionDataProvider: tags: [api_platform.collection_data_provider] autowire: true ``` !!! 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.7.0/docs/infrastructure/doctrine-collections.md000066400000000000000000000016211335536502400234770ustar00rootroot00000000000000# 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 use 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` it'll be lost. To overcome, two hydration modes are available 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 FROM 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.7.0/docs/infrastructure/elasticsearch.md000066400000000000000000000070361335536502400221740ustar00rootroot00000000000000# Elasticsearch An overview of available infrastructural code when using Elasticsearch's [PHP Api][elasticsearch-project]. - Requires [elasticsearch/elasticsearch] ## Projection Type Registry An Elasticsearch tailored [projection type registry](../projection/type-registry.md) is provided by `MsgPhp\Domain\Infra\Elasticsearch\ProjectionTypeRegistry`. 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 ProjectionTypeRegistry($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 ProjectionTypeRegistry($client, 'some_index', [ MyProjection::class, ]); ``` ## Projection Repository An Elasticsearch tailored [projection repository](../projection/repositories.md) is provided by `MsgPhp\Domain\Infra\Elasticsearch\ProjectionRepository`. 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.7.0/docs/infrastructure/symfony-console.md000066400000000000000000000135221335536502400225230ustar00rootroot00000000000000# 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. ### `InitializeProjectionTypesCommand` Initializes the [projection type registry](../projection/type-registry.md). ```bash bin/console projection:initialize-types [--force] ``` ### `SynchronizeProjectionsCommand` 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.7.0/docs/infrastructure/symfony-messenger.md000066400000000000000000000016571335536502400230570ustar00rootroot00000000000000# 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.7.0/docs/infrastructure/uuid.md000066400000000000000000000022631335536502400203250ustar00rootroot00000000000000# 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(); } } // --- 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.7.0/docs/message-driven/message-bus.md000066400000000000000000000015671335536502400214310ustar00rootroot00000000000000# 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). !!! note See the [reference](../reference/messages.md) page for all available messages provided per domain ## 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.7.0/docs/message-driven/message-dispatcher.md000066400000000000000000000015121335536502400227540ustar00rootroot00000000000000# 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.7.0/docs/projection/000077500000000000000000000000001335536502400161265ustar00rootroot00000000000000msgphp-0.7.0/docs/projection/document-transformers.md000066400000000000000000000031171335536502400230130ustar00rootroot00000000000000# Projection Document Transformers A projection document transformer is bound to `MsgPhp\Domain\Projection\ProjectionDocumentTransformerInterface`. Its purpose is to transform arbitrary objects into [projection documents](documents.md). ## API ### `transform(object $object): ProjectionDocument` Transforms the domain object into a projection document. ## Basic example ```php id = $id; } } class MyProjection implements ProjectionInterface { public $id; public $someField; public static function fromDocument(array $document): ProjectionInterface { $projection = new static(); $projection->id = $document['id'] ?? null; $projection->someField = $document['some_field'] ?? null; return $projection; } } class MyTransformer implements ProjectionDocumentTransformerInterface { public function transform($object): ProjectionDocument { if ($object instanceof MyEntity) { return new ProjectionDocument(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.7.0/docs/projection/documents.md000066400000000000000000000024771335536502400204630ustar00rootroot00000000000000# Projection Documents A projection document is a value object of type `MsgPhp\Domain\Projection\ProjectionDocument`. 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 source object, 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 data. --- ### `toProjection(): ProjectionInterface` 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/ProjectionDocument.html#page-content msgphp-0.7.0/docs/projection/models.md000066400000000000000000000025671335536502400177450ustar00rootroot00000000000000# Projections A projection is a model object and bound to `MsgPhp\Domain\Projection\ProjectionInterface`. Its purpose is to convert raw model data (a document) into a projection. 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 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 [projection data provider](../infrastructure/api-platform.md#projection-data-provider) ## API ### `static fromDocument(array $document): ProjectionInterface` 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.7.0/docs/projection/repositories.md000066400000000000000000000033171335536502400212030ustar00rootroot00000000000000# Projection Repositories A projection repository is bound to `MsgPhp\Domain\Projection\ProjectionRepositoryInterface`. Its purpose is to store and query [projection documents](documents.md). ## API ### `findAll(string $type, int $offset = 0, int $limit = 0): ProjectionDocument[]` Finds all projection documents by type. --- ### `find(string $type, string $id): ?ProjectionDocument` Finds a single projection document 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(ProjectionDocument $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\ProjectionRepository` An Elasticsearch tailored projection repository. - [Read more](../infrastructure/elasticsearch.md#projection-repository) ## Basic example ```php find(MyProjection::class, $id); if (null === $projection) { $document = ProjectionDocument::create(MyProjection::class, $id, [ 'some_field' => 'value', ]); $repository->save($document); } ``` msgphp-0.7.0/docs/projection/synchronization.md000066400000000000000000000043421335536502400217140ustar00rootroot00000000000000# Projection Synchronization `MsgPhp\Domain\Projection\ProjectionSynchronization` is a utility domain service. Its purpose is to ease synchronizing [projection documents](documents.md) from source objects. ## API ### `synchronize(): iterable` Yields all projection documents attempted to be synchronized. The actual document status can be read from [`ProjectionDocument::$status`][api-projection-document-status]. ## Basic example ```php id = $id; } } /** @var ProjectionTypeRegistryInterface $typeRegistry */ $typeRegistry = ...; /** @var ProjectionRepositoryInterface $repository */ $repository = ...; /** @var ProjectionDocumentTransformerInterface $transformer */ $transformer = ...; $provider = new ProjectionDocumentProvider($transformer, [ function (): iterable { yield new MyEntity(1); yield new MyEntity(2); }, ]); $synchronization = new ProjectionSynchronization($typeRegistry, $repository, $provider); // --- USAGE --- foreach ($synchronization->synchronize() as $document) { if (ProjectionDocument::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#synchronizeprojectionscommand) [api-projection-document-status]: https://msgphp.github.io/api/MsgPhp/Domain/Projection/ProjectionDocument.html#property_status msgphp-0.7.0/docs/projection/type-registry.md000066400000000000000000000024351335536502400213030ustar00rootroot00000000000000# Projection Type Registry A projection type registry is bound to `MsgPhp\Domain\Projection\ProjectionTypeRegistryInterface`. 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\ProjectionTypeRegistry` An Elasticsearch tailored projection type registry. - [Read more](../infrastructure/elasticsearch.md#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#initializeprojectiontypescommand) msgphp-0.7.0/docs/reference/000077500000000000000000000000001335536502400157105ustar00rootroot00000000000000msgphp-0.7.0/docs/reference/doctrine-identifier-types.md000066400000000000000000000012471335536502400233270ustar00rootroot00000000000000# 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.7.0/docs/reference/domain-events.md000066400000000000000000000006311335536502400210030ustar00rootroot00000000000000# Domain Events Reference of available [domain events](../event-sourcing/events.md) per domain. ## `msgphp/domain` - `MsgPhp\Domain\Event\ConfirmEvent` - `MsgPhp\Domain\Event\DisableEvent` - `MsgPhp\Domain\Event\EnableEvent` ## `msgphp/user` - `MsgPhp\User\Event\Domain\ChangeCredentialEvent` - `MsgPhp\User\Event\Domain\RequestPasswordEvent` msgphp-0.7.0/docs/reference/entities.md000066400000000000000000000030201335536502400200510ustar00rootroot00000000000000# Entities Reference of available [entities](../ddd/entities.md) per domain. ## `msgphp/domain` ### Fields - `MsgPhp\Domain\Entity\Fields\CreatedAtField` - `MsgPhp\Domain\Entity\Fields\EnabledField` - `MsgPhp\Domain\Entity\Fields\LastUpdatedAtField` ### Features - `MsgPhp\Domain\Entity\Features\CanBeConfirmed` - `MsgPhp\Domain\Entity\Features\CanBeEnabled` ## `msgphp/eav` ### Entities - `MsgPhp\Eav\Entity\Attribute` - `MsgPhp\Eav\Entity\AttributeValue` ### Fields - `MsgPhp\Eav\Entity\Fields\AttributesField` ### Features - `MsgPhp\Eav\Entity\Features\EntityAttributeValue` ## `msgphp/user` ### Entities - `MsgPhp\User\Entity\Role` - `MsgPhp\User\Entity\User` - `MsgPhp\User\Entity\UserAttributeValue` - `MsgPhp\User\Entity\UserEmail` - `MsgPhp\User\Entity\UserRole` - `MsgPhp\User\Entity\Username` ### 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` ### 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.7.0/docs/reference/identifiers.md000066400000000000000000000015061335536502400205410ustar00rootroot00000000000000# 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.7.0/docs/reference/messages.md000066400000000000000000000043301335536502400200410ustar00rootroot00000000000000# Messages Reference of available messages per domain that can be dispatched using a [message bus](../message-driven/message-bus.md). ## `msgphp/domain` ### Commands - `MsgPhp\Domain\Command\DeleteProjectionDocumentCommand` - `MsgPhp\Domain\Command\SaveProjectionDocumentCommand` ### Events - `MsgPhp\Domain\Event\ProjectionDocumentDeletedEvent` - `MsgPhp\Domain\Event\ProjectionDocumentSavedEvent` ## `msgphp/eav` ### Commands - `MsgPhp\Eav\Command\CreateAttributeCommand` - `MsgPhp\Eav\Command\DeleteAttributeCommand` ### Events - `MsgPhp\Eav\Event\AttributeCreatedEvent` - `MsgPhp\Eav\Event\AttributeDeletedEvent` ## `msgphp/user` ### Commands - `MsgPhp\User\Command\AddUserAttributeValueCommand` - `MsgPhp\User\Command\AddUserEmailCommand` - `MsgPhp\User\Command\AddUserRoleCommand` - `MsgPhp\User\Command\ChangeUserAttributeValueCommand` - `MsgPhp\User\Command\ChangeUserCredentialCommand` - `MsgPhp\User\Command\ConfirmUserCommand` - `MsgPhp\User\Command\ConfirmUserEmailCommand` - `MsgPhp\User\Command\CreateRoleCommand` - `MsgPhp\User\Command\CreateUserCommand` - `MsgPhp\User\Command\DeleteRoleCommand` - `MsgPhp\User\Command\DeleteUserAttributeValueCommand` - `MsgPhp\User\Command\DeleteUserCommand` - `MsgPhp\User\Command\DeleteUserEmailCommand` - `MsgPhp\User\Command\DeleteUserRoleCommand` - `MsgPhp\User\Command\DisableUserCommand` - `MsgPhp\User\Command\EnableUserCommand` - `MsgPhp\User\Command\RequestUserPasswordCommand` ### Events - `MsgPhp\User\Event\RoleCreatedEvent` - `MsgPhp\User\Event\RoleDeletedEvent` - `MsgPhp\User\Event\UserAttributeValueAddedEvent` - `MsgPhp\User\Event\UserAttributeValueChangedEvent` - `MsgPhp\User\Event\UserAttributeValueDeletedEvent` - `MsgPhp\User\Event\UserConfirmedEvent` - `MsgPhp\User\Event\UserCreatedEvent` - `MsgPhp\User\Event\UserCredentialChangedEvent` - `MsgPhp\User\Event\UserDeletedEvent` - `MsgPhp\User\Event\UserDisabledEvent` - `MsgPhp\User\Event\UserEmailAddedEvent` - `MsgPhp\User\Event\UserEmailConfirmedEvent` - `MsgPhp\User\Event\UserEmailDeletedEvent` - `MsgPhp\User\Event\UserEnabledEvent` - `MsgPhp\User\Event\UserPasswordRequestedEvent` - `MsgPhp\User\Event\UserRoleAddedEvent` - `MsgPhp\User\Event\UserRoleDeletedEvent` msgphp-0.7.0/docs/reference/repositories.md000066400000000000000000000010761335536502400207650ustar00rootroot00000000000000# Repositories Reference of available [repositories](../ddd/repositories.md) per domain. ## `msgphp/eav` - `MsgPhp\Eav\Repository\AttributeRepositoryInterface` ## `msgphp/user` - `MsgPhp\User\Repository\RoleRepositoryInterface` - `MsgPhp\User\Repository\UserAttributeValueRepositoryInterface` - `MsgPhp\User\Repository\UserEmailRepositoryInterface` - `MsgPhp\User\Repository\UserRepositoryInterface` - `MsgPhp\User\Repository\UserRoleRepositoryInterface` - `MsgPhp\User\Repository\UsernameRepositoryInterface` msgphp-0.7.0/mkdocs.yml000066400000000000000000000050071335536502400150270ustar00rootroot00000000000000site_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 - Entities: ddd/entities.md - Repositories: ddd/repositories.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 - Configuring A Message Bus: cookbook/configuring-a-message-bus.md - Reference: - Identifiers: reference/identifiers.md - Entities: reference/entities.md - Repositories: reference/repositories.md - Messages: reference/messages.md - Domain Events: reference/domain-events.md - Doctrine Identifier Types: reference/doctrine-identifier-types.md msgphp-0.7.0/phpstan.neon000066400000000000000000000036471335536502400153720ustar00rootroot00000000000000includes: - vendor/phpstan/phpstan-phpunit/extension.neon - vendor/phpstan/phpstan-phpunit/rules.neon parameters: level: max autoload_directories: - tests/fixtures/sa 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\.#' - '#Static property MsgPhp\\Domain\\Tests\\Infra\\Doctrine\\.+Test::\$em \(Doctrine\\ORM\\EntityManager\) does not accept null\.#' - '#Class MsgPhp\\Domain\\Tests\\Factory\\WrongCase referenced with incorrect case: MsgPhp\\Domain\\Tests\\Factory\\wrongcase\.#' # phpstan - '#Cannot call method getName\(\) on ReflectionClass\|null\.#' # doctrine - '#Parameter \#1 \$hydrationMode of method Doctrine\\ORM\\AbstractQuery::getResult\(\) expects int, string given\.#' - '#Parameter \#1 \$hydrationMode of method Doctrine\\ORM\\AbstractQuery::getSingleResult\(\) expects int\|null, string given\.#' # msgphp - '#Method MsgPhp\\.+\\Infra\\Doctrine\\Repository\\.+Repository::find.*\(\) should return MsgPhp\\.+\\Entity\\.+ but returns object\.#' - '#Parameter \#1 \$command of method MsgPhp\\.+\\Command\\Handler\\.+Handler::getDomainEvent(Handler)?\(\) expects MsgPhp\\.+\\Command\\.+Command, object given\.#' - '#Cannot call method classMappingNode\(\) on Symfony\\Component\\Config\\Definition\\Builder\\NodeParentInterface\|null\.#' excludes_analyse: - '*/vendor/*' - src/UserBundle/Resources/skeleton/ - src/UserBundle/Maker/UserMaker.php msgphp-0.7.0/src/000077500000000000000000000000001335536502400136115ustar00rootroot00000000000000msgphp-0.7.0/src/Domain/000077500000000000000000000000001335536502400150205ustar00rootroot00000000000000msgphp-0.7.0/src/Domain/.gitattributes000066400000000000000000000000641335536502400177130ustar00rootroot00000000000000Tests/ export-ignore phpunit.xml.dist export-ignore msgphp-0.7.0/src/Domain/.gitignore000066400000000000000000000000471335536502400170110ustar00rootroot00000000000000/composer.lock /composer.phar /vendor/ msgphp-0.7.0/src/Domain/Command/000077500000000000000000000000001335536502400163765ustar00rootroot00000000000000msgphp-0.7.0/src/Domain/Command/DeleteProjectionDocumentCommand.php000066400000000000000000000005211335536502400253420ustar00rootroot00000000000000 */ class DeleteProjectionDocumentCommand { public $type; public $id; final public function __construct(string $type, string $id) { $this->type = $type; $this->id = $id; } } msgphp-0.7.0/src/Domain/Command/EventSourcingCommandHandlerTrait.php000066400000000000000000000021731335536502400255060ustar00rootroot00000000000000 */ 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.7.0/src/Domain/Command/Handler/000077500000000000000000000000001335536502400177535ustar00rootroot00000000000000msgphp-0.7.0/src/Domain/Command/Handler/DeleteProjectionDocumentHandler.php000066400000000000000000000022401335536502400267160ustar00rootroot00000000000000 */ final class DeleteProjectionDocumentHandler { use MessageDispatchingTrait; private $repository; public function __construct(DomainObjectFactoryInterface $factory, DomainMessageBusInterface $bus, ProjectionRepositoryInterface $repository) { $this->factory = $factory; $this->bus = $bus; $this->repository = $repository; } public function __invoke(DeleteProjectionDocumentCommand $command): void { if (null === $document = $this->repository->find($command->type, $command->id)) { return; } $this->repository->delete($document->getType(), $document->getId()); $this->dispatch(ProjectionDocumentDeletedEvent::class, [$document]); } } msgphp-0.7.0/src/Domain/Command/Handler/SaveProjectionDocumentHandler.php000066400000000000000000000021551335536502400264170ustar00rootroot00000000000000 */ final class SaveProjectionDocumentHandler { use MessageDispatchingTrait; private $repository; public function __construct(DomainObjectFactoryInterface $factory, DomainMessageBusInterface $bus, ProjectionRepositoryInterface $repository) { $this->factory = $factory; $this->bus = $bus; $this->repository = $repository; } public function __invoke(SaveProjectionDocumentCommand $command): void { $document = new ProjectionDocument($command->type, $command->id, $command->body); $this->repository->save($document); $this->dispatch(ProjectionDocumentSavedEvent::class, [$document]); } } msgphp-0.7.0/src/Domain/Command/SaveProjectionDocumentCommand.php000066400000000000000000000007411335536502400250420ustar00rootroot00000000000000 */ class SaveProjectionDocumentCommand { public $type; public $id; public $body; final public function __construct(ProjectionDocument $document) { $this->type = $document->getType(); $this->id = $document->getId(); $this->body = $document->getBody(); } } msgphp-0.7.0/src/Domain/DomainCollection.php000066400000000000000000000105551335536502400207620ustar00rootroot00000000000000 */ final class DomainCollection implements DomainCollectionInterface { private $elements; 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.7.0/src/Domain/DomainCollectionInterface.php000066400000000000000000000013501335536502400225740ustar00rootroot00000000000000 */ 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.7.0/src/Domain/DomainId.php000066400000000000000000000024761335536502400172260ustar00rootroot00000000000000 */ class DomainId implements DomainIdInterface { private $id; /** * @return static */ 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.7.0/src/Domain/DomainIdInterface.php000066400000000000000000000006361335536502400210430ustar00rootroot00000000000000 */ 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.7.0/src/Domain/DomainIdentityHelper.php000066400000000000000000000067421335536502400216230ustar00rootroot00000000000000 */ 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.7.0/src/Domain/DomainIdentityMappingInterface.php000066400000000000000000000005611335536502400236110ustar00rootroot00000000000000 */ interface DomainIdentityMappingInterface { /** * @return string[] */ public function getIdentifierFieldNames(string $class): array; /** * @param object $object */ public function getIdentity($object): array; } msgphp-0.7.0/src/Domain/Entity/000077500000000000000000000000001335536502400162745ustar00rootroot00000000000000msgphp-0.7.0/src/Domain/Entity/Features/000077500000000000000000000000001335536502400200525ustar00rootroot00000000000000msgphp-0.7.0/src/Domain/Entity/Features/CanBeConfirmed.php000066400000000000000000000017431335536502400233670ustar00rootroot00000000000000 */ 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.7.0/src/Domain/Entity/Features/CanBeEnabled.php000066400000000000000000000015071335536502400230110ustar00rootroot00000000000000 */ 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.7.0/src/Domain/Entity/Fields/000077500000000000000000000000001335536502400175025ustar00rootroot00000000000000msgphp-0.7.0/src/Domain/Entity/Fields/CreatedAtField.php000066400000000000000000000005011335536502400230070ustar00rootroot00000000000000 */ trait CreatedAtField { /** @var \DateTimeInterface */ private $createdAt; public function getCreatedAt(): \DateTimeInterface { return $this->createdAt; } } msgphp-0.7.0/src/Domain/Entity/Fields/EnabledField.php000066400000000000000000000004441335536502400225130ustar00rootroot00000000000000 */ trait EnabledField { /** @var bool */ private $enabled = false; public function isEnabled(): bool { return $this->enabled; } } msgphp-0.7.0/src/Domain/Entity/Fields/LastUpdatedAtField.php000066400000000000000000000005211335536502400236540ustar00rootroot00000000000000 */ trait LastUpdatedAtField { /** @var \DateTimeInterface */ private $lastUpdatedAt; public function getLastUpdatedAt(): \DateTimeInterface { return $this->lastUpdatedAt; } } msgphp-0.7.0/src/Domain/Event/000077500000000000000000000000001335536502400161015ustar00rootroot00000000000000msgphp-0.7.0/src/Domain/Event/ConfirmEvent.php000066400000000000000000000002671335536502400212160ustar00rootroot00000000000000 */ class ConfirmEvent implements DomainEventInterface { } msgphp-0.7.0/src/Domain/Event/DisableEvent.php000066400000000000000000000002671335536502400211640ustar00rootroot00000000000000 */ class DisableEvent implements DomainEventInterface { } msgphp-0.7.0/src/Domain/Event/DomainEventHandlerInterface.php000066400000000000000000000003561335536502400241460ustar00rootroot00000000000000 */ interface DomainEventHandlerInterface { public function handleEvent(DomainEventInterface $event): bool; } msgphp-0.7.0/src/Domain/Event/DomainEventHandlerTrait.php000066400000000000000000000012651335536502400233310ustar00rootroot00000000000000 */ 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.7.0/src/Domain/Event/DomainEventInterface.php000066400000000000000000000002431335536502400226430ustar00rootroot00000000000000 */ interface DomainEventInterface { } msgphp-0.7.0/src/Domain/Event/EnableEvent.php000066400000000000000000000002661335536502400210060ustar00rootroot00000000000000 */ class EnableEvent implements DomainEventInterface { } msgphp-0.7.0/src/Domain/Event/ProjectionDocumentDeletedEvent.php000066400000000000000000000005471335536502400247240ustar00rootroot00000000000000 */ class ProjectionDocumentDeletedEvent { public $document; final public function __construct(ProjectionDocument $document) { $this->document = $document; } } msgphp-0.7.0/src/Domain/Event/ProjectionDocumentSavedEvent.php000066400000000000000000000005451335536502400244160ustar00rootroot00000000000000 */ class ProjectionDocumentSavedEvent { public $document; final public function __construct(ProjectionDocument $document) { $this->document = $document; } } msgphp-0.7.0/src/Domain/Exception/000077500000000000000000000000001335536502400167565ustar00rootroot00000000000000msgphp-0.7.0/src/Domain/Exception/DomainExceptionInterface.php000066400000000000000000000002531335536502400243760ustar00rootroot00000000000000 */ interface DomainExceptionInterface { } msgphp-0.7.0/src/Domain/Exception/DuplicateEntityException.php000066400000000000000000000006651335536502400244640ustar00rootroot00000000000000 */ 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, (string) json_encode($id))); } } msgphp-0.7.0/src/Domain/Exception/EntityNotFoundException.php000066400000000000000000000012141335536502400242750ustar00rootroot00000000000000 */ 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, (string) 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, (string) json_encode($fields))); } } msgphp-0.7.0/src/Domain/Exception/InvalidClassException.php000066400000000000000000000010631335536502400237220ustar00rootroot00000000000000 */ 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.7.0/src/Domain/Exception/UnknownDomainEventException.php000066400000000000000000000010711335536502400251360ustar00rootroot00000000000000 */ 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.7.0/src/Domain/Factory/000077500000000000000000000000001335536502400164275ustar00rootroot00000000000000msgphp-0.7.0/src/Domain/Factory/ChainObjectFactory.php000066400000000000000000000014261335536502400226440ustar00rootroot00000000000000 */ 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.7.0/src/Domain/Factory/ClassMappingObjectFactory.php000066400000000000000000000011111335536502400241720ustar00rootroot00000000000000 */ 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.7.0/src/Domain/Factory/ClassMethodResolver.php000066400000000000000000000044471335536502400231010ustar00rootroot00000000000000 */ 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.7.0/src/Domain/Factory/DomainCollectionFactory.php000066400000000000000000000025011335536502400237110ustar00rootroot00000000000000 */ 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); } public static function createFromCallable(callable $value): DomainCollectionInterface { $iterator = new class($value) implements \IteratorAggregate { private $callback; public function __construct(callable $value) { $this->callback = $value; } public function getIterator(): \Traversable { $iterable = ($this->callback)(); return \is_array($iterable) ? new \ArrayIterator($iterable) : $iterable; } }; return self::create($iterator); } private function __construct() { } } msgphp-0.7.0/src/Domain/Factory/DomainIdFactory.php000066400000000000000000000014461335536502400221610ustar00rootroot00000000000000 */ 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.7.0/src/Domain/Factory/DomainObjectFactory.php000066400000000000000000000044251335536502400230330ustar00rootroot00000000000000 */ 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.7.0/src/Domain/Factory/DomainObjectFactoryInterface.php000066400000000000000000000004231335536502400246460ustar00rootroot00000000000000 */ interface DomainObjectFactoryInterface { /** * @return object */ public function create(string $class, array $context = []); } msgphp-0.7.0/src/Domain/Factory/EntityAwareFactory.php000066400000000000000000000035531335536502400227320ustar00rootroot00000000000000 */ 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.7.0/src/Domain/Factory/EntityAwareFactoryInterface.php000066400000000000000000000007401335536502400245460ustar00rootroot00000000000000 */ 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.7.0/src/Domain/Infra/000077500000000000000000000000001335536502400160575ustar00rootroot00000000000000msgphp-0.7.0/src/Domain/Infra/ApiPlatform/000077500000000000000000000000001335536502400202755ustar00rootroot00000000000000msgphp-0.7.0/src/Domain/Infra/ApiPlatform/Paginator.php000066400000000000000000000021211335536502400227260ustar00rootroot00000000000000 */ final class Paginator implements \IteratorAggregate, PaginatorInterface { private $collection; public function __construct(PaginatedDomainCollectionInterface $collection) { $this->collection = $collection; } public function getIterator(): \Traversable { return $this->collection->getIterator(); } public function count(): int { return \count($this->collection); } public function getLastPage(): float { return $this->collection->getLastPage(); } public function getTotalItems(): float { return $this->collection->getTotalCount(); } public function getCurrentPage(): float { return $this->collection->getCurrentPage(); } public function getItemsPerPage(): float { return $this->collection->getLimit(); } } msgphp-0.7.0/src/Domain/Infra/ApiPlatform/ProjectionDataProvider.php000066400000000000000000000036731335536502400254400ustar00rootroot00000000000000 */ final class ProjectionDataProvider implements CollectionDataProviderInterface, ItemDataProviderInterface, RestrictedDataProviderInterface { private $typeRegistry; private $repository; public function __construct(ProjectionTypeRegistryInterface $typeRegistry, ProjectionRepositoryInterface $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 ProjectionInterface[] */ public function getCollection(string $resourceClass, string $operationName = null): iterable { $collection = $this->repository->findAll($resourceClass); return new Paginator(new PaginatedDomainCollection((function () use ($collection): iterable { foreach ($collection as $document) { yield $document->toProjection(); } })(), $collection->getOffset(), $collection->getLimit(), (float) \count($collection), $collection->getTotalCount())); } public function getItem(string $resourceClass, $id, string $operationName = null, array $context = []): ?ProjectionInterface { $document = $this->repository->find($resourceClass, $id); return null === $document ? null : $document->toProjection(); } } msgphp-0.7.0/src/Domain/Infra/Config/000077500000000000000000000000001335536502400172645ustar00rootroot00000000000000msgphp-0.7.0/src/Domain/Infra/Config/ClassMappingNode.php000066400000000000000000000023041335536502400231630ustar00rootroot00000000000000 */ 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.7.0/src/Domain/Infra/Config/ClassMappingNodeDefinition.php000066400000000000000000000134641335536502400252050ustar00rootroot00000000000000 */ 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.7.0/src/Domain/Infra/Config/NodeBuilder.php000066400000000000000000000012521335536502400221710ustar00rootroot00000000000000 */ 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.7.0/src/Domain/Infra/Config/TreeBuilder.php000066400000000000000000000012401335536502400222000ustar00rootroot00000000000000 */ 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.7.0/src/Domain/Infra/Console/000077500000000000000000000000001335536502400174615ustar00rootroot00000000000000msgphp-0.7.0/src/Domain/Infra/Console/Command/000077500000000000000000000000001335536502400210375ustar00rootroot00000000000000msgphp-0.7.0/src/Domain/Infra/Console/Command/InitializeProjectionTypesCommand.php000066400000000000000000000026641335536502400302420ustar00rootroot00000000000000 */ final class InitializeProjectionTypesCommand extends Command { protected static $defaultName = 'projection:initialize-types'; private $typeRegistry; public function __construct(ProjectionTypeRegistryInterface $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.7.0/src/Domain/Infra/Console/Command/SynchronizeProjectionsCommand.php000066400000000000000000000035321335536502400276050ustar00rootroot00000000000000 */ final class SynchronizeProjectionsCommand extends Command { protected static $defaultName = 'projection:synchronize'; private $synchronization; private $logger; public function __construct(ProjectionSynchronization $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 (ProjectionDocument::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.7.0/src/Domain/Infra/Console/Context/000077500000000000000000000000001335536502400211055ustar00rootroot00000000000000msgphp-0.7.0/src/Domain/Infra/Console/Context/ClassContextElementFactory.php000066400000000000000000000007451335536502400271000ustar00rootroot00000000000000 */ 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.7.0/src/Domain/Infra/Console/Context/ClassContextElementFactoryInterface.php000066400000000000000000000004431335536502400307140ustar00rootroot00000000000000 */ interface ClassContextElementFactoryInterface { public function getElement(string $class, string $method, string $argument): ContextElement; } msgphp-0.7.0/src/Domain/Infra/Console/Context/ClassContextFactory.php000066400000000000000000000200421335536502400255560ustar00rootroot00000000000000 */ 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.7.0/src/Domain/Infra/Console/Context/ContextElement.php000066400000000000000000000041401335536502400245530ustar00rootroot00000000000000 */ 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.7.0/src/Domain/Infra/Console/Context/ContextFactoryInterface.php000066400000000000000000000007751335536502400264240ustar00rootroot00000000000000 */ interface ContextFactoryInterface { public function configure(InputDefinition $definition): void; public function getContext(InputInterface $input, StyleInterface $io, array $values = []): array; } msgphp-0.7.0/src/Domain/Infra/Console/Context/DoctrineEntityContextFactory.php000066400000000000000000000057221335536502400274650ustar00rootroot00000000000000 */ 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.', json_encode($value))); } // @todo 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.7.0/src/Domain/Infra/Console/MessageReceiver.php000066400000000000000000000014511335536502400232440ustar00rootroot00000000000000 */ 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.7.0/src/Domain/Infra/DependencyInjection/000077500000000000000000000000001335536502400220005ustar00rootroot00000000000000msgphp-0.7.0/src/Domain/Infra/DependencyInjection/BundleHelper.php000066400000000000000000000264411335536502400250710ustar00rootroot00000000000000 * * @internal */ final class BundleHelper { private static $initialized = []; public static function build(ContainerBuilder $container): void { if ($initialized = &self::getInitialized($container, __FUNCTION__)) { return; } self::initIdentityMapping($container); self::initObjectFactory($container); self::initMessageBus($container); if (FeatureDetection::isDoctrineOrmAvailable($container)) { self::initDoctrineOrm($container); } if (FeatureDetection::isConsoleAvailable($container)) { self::initConsole($container); } $container->addCompilerPass(new Compiler\ResolveDomainPass(), PassConfig::TYPE_BEFORE_OPTIMIZATION, 100); $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 initIdentityMapping(ContainerBuilder $container): void { if (FeatureDetection::isDoctrineOrmAvailable($container)) { $container->register(DoctrineInfra\DomainIdentityMapping::class) ->setPublic(false) ->setArgument('$em', new Reference('msgphp.doctrine.entity_manager')) ->setArgument('$classMapping', '%msgphp.domain.class_mapping%'); $container->setAlias(DomainIdentityMappingInterface::class, new Alias(DoctrineInfra\DomainIdentityMapping::class, false)); } else { $container->register(InMemoryInfra\DomainIdentityMapping::class) ->setPublic(false) ->setArgument('$mapping', '%msgphp.domain.identity_mapping%') ->setArgument('$accessor', $container->autowire(InMemoryInfra\ObjectFieldAccessor::class)); $container->setAlias(DomainIdentityMappingInterface::class, new Alias(InMemoryInfra\DomainIdentityMapping::class, false)); } $container->autowire(DomainIdentityHelper::class) ->setPublic(false); } private static function initObjectFactory(ContainerBuilder $container): void { $container->register(DomainObjectFactory::class) ->setPublic(false) ->addMethodCall('setNestedFactory', [new Reference(DomainObjectFactoryInterface::class)]); $container->setAlias(DomainObjectFactoryInterface::class, new Alias(DomainObjectFactory::class, false)); $container->register(ClassMappingObjectFactory::class) ->setPublic(false) ->setDecoratedService(DomainObjectFactory::class) ->setArgument('$factory', new Reference(ClassMappingObjectFactory::class.'.inner')) ->setArgument('$mapping', '%msgphp.domain.class_mapping%'); $container->autowire(EntityAwareFactory::class) ->setPublic(false) ->setDecoratedService(DomainObjectFactory::class) ->setArgument('$factory', new Reference(EntityAwareFactory::class.'.inner')) ->setArgument('$identifierMapping', '%msgphp.domain.id_class_mapping%'); $container->setAlias(EntityAwareFactoryInterface::class, new Alias(DomainObjectFactoryInterface::class, false)); if (FeatureDetection::isDoctrineOrmAvailable($container)) { $container->register(DoctrineInfra\EntityAwareFactory::class) ->setPublic(false) ->setDecoratedService(EntityAwareFactory::class) ->setArgument('$factory', new Reference(DoctrineInfra\EntityAwareFactory::class.'.inner')) ->setArgument('$em', new Reference('msgphp.doctrine.entity_manager')) ->setArgument('$classMapping', '%msgphp.domain.class_mapping%'); } } private static function initMessageBus(ContainerBuilder $container): void { if (FeatureDetection::isMessengerAvailable($container)) { $type = 'messenger'; $container->setAlias('msgphp.messenger.command_bus', new Alias('message_bus', false)); $commandBus = ContainerHelper::registerAnonymous($container, MessengerInfra\DomainMessageBus::class, false, $commandBusId); $commandBus->setArgument('$bus', new Reference('msgphp.messenger.command_bus')); $container->setAlias('msgphp.messenger.event_bus', new Alias('message_bus', false)); $eventBus = ContainerHelper::registerAnonymous($container, MessengerInfra\DomainMessageBus::class); $eventBus->setArgument('$bus', new Reference('msgphp.messenger.event_bus')); if (FeatureDetection::isConsoleAvailable($container)) { $container->autowire('msgphp.messenger.console_message_receiver', MessengerInfra\Middleware\ConsoleMessageReceiverMiddleware::class) ->setPublic(false); } } elseif (FeatureDetection::hasSimpleBusCommandBusBundle($container)) { $type = 'simple_bus'; $container->setAlias('msgphp.simple_bus.command_bus', new Alias('simple_bus.command_bus', false)); $commandBus = ContainerHelper::registerAnonymous($container, SimpleBusInfra\DomainMessageBus::class, false, $commandBusId); $commandBus->setArgument('$bus', new Reference('msgphp.simple_bus.command_bus')); if (FeatureDetection::hasSimpleBusEventBusBundle($container)) { $container->setAlias('msgphp.simple_bus.event_bus', new Alias('simple_bus.event_bus', false)); $eventBus = ContainerHelper::registerAnonymous($container, SimpleBusInfra\DomainMessageBus::class); $eventBus->setArgument('$bus', new Reference('msgphp.simple_bus.event_bus')); } else { $eventBus = null; } if (FeatureDetection::isConsoleAvailable($container)) { $consoleReceiver = $container->autowire(SimpleBusInfra\Middleware\ConsoleMessageReceiverMiddleware::class) ->setPublic(false) ->addTag('command_bus_middleware'); if (null !== $eventBus) { $consoleReceiver->addTag('event_bus_middleware'); } } } else { return; } $container->setAlias('msgphp.command_bus', new Alias('msgphp.'.$type.'.command_bus', false)); if (null === $eventBus) { $container->setAlias(DomainMessageBusInterface::class, new Alias($commandBusId, false)); return; } $container->register(DomainMessageBus::class) ->setPublic(false) ->setArgument('$commandBus', $commandBus) ->setArgument('$eventBus', $eventBus) ->setArgument('$eventClasses', '%msgphp.domain.events%'); $container->setAlias(DomainMessageBusInterface::class, new Alias(DomainMessageBus::class, false)); } private static function initDoctrineOrm(ContainerBuilder $container): void { @mkdir($mappingDir = $container->getParameterBag()->resolveValue('%kernel.cache_dir%/msgphp/doctrine-mapping'), 0777, true); $container->addCompilerPass(new Compiler\DoctrineObjectFieldMappingPass(), PassConfig::TYPE_BEFORE_OPTIMIZATION, 100); $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, ], ], ]]); $container->setAlias('msgphp.doctrine.entity_manager', new Alias('doctrine.orm.entity_manager', false)); $container->register(DoctrineInfra\ObjectFieldMappings::class) ->setPublic(false) ->addTag('msgphp.doctrine.object_field_mappings', ['priority' => -100]); $container->register(DoctrineInfra\Event\ObjectFieldMappingListener::class) ->setPublic(false) ->addTag('doctrine.event_listener', ['event' => DoctrineOrmEvents::loadClassMetadata]) ->addTag('msgphp.domain.process_class_mapping', ['argument' => '$mappings']); if (FeatureDetection::hasFrameworkBundle($container)) { $container->register(DoctrineInfra\MappingCacheWarmer::class) ->setPublic(false) ->setArgument('$dirName', 'msgphp/doctrine-mapping') ->setArgument('$mappingFiles', '%msgphp.doctrine.mapping_files%') ->addTag('kernel.cache_warmer', ['priority' => 100]); } } private static function initConsole(ContainerBuilder $container): void { $container->autowire(ConsoleInfra\Context\ClassContextFactory::class) ->setPublic(false) ->setAbstract(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']); } 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.7.0/src/Domain/Infra/DependencyInjection/Compiler/000077500000000000000000000000001335536502400235525ustar00rootroot00000000000000msgphp-0.7.0/src/Domain/Infra/DependencyInjection/Compiler/DoctrineObjectFieldMappingPass.php000066400000000000000000000040421335536502400322700ustar00rootroot00000000000000 */ final class DoctrineObjectFieldMappingPass implements CompilerPassInterface { use PriorityTaggedServiceTrait; private $tagName; private $listenerId; public function __construct(string $tagName = 'msgphp.doctrine.object_field_mappings', string $listenerId = ObjectFieldMappingListener::class) { $this->tagName = $tagName; $this->listenerId = $listenerId; } public function process(ContainerBuilder $container): void { $mappings = []; foreach ($this->findAndSortTaggedServices($this->tagName, $container) as $providerId) { $providerId = (string) $providerId; $providerClass = $container->findDefinition($providerId)->getClass() ?? $providerId; if (!is_subclass_of($providerClass, ObjectFieldMappingsProviderInterface::class)) { throw new InvalidArgumentException(sprintf('Provider "%s" must implement "%s".', $providerId, ObjectFieldMappingsProviderInterface::class)); } foreach ($providerClass::provideObjectFieldMappings() as $class => $mapping) { if (isset($mappings[$class])) { continue; } $mappings[$class] = $mapping; } } if ($mappings) { $container->getDefinition($this->listenerId) ->setArgument('$mappings', $mappings); } else { $container->removeDefinition($this->listenerId); } } } msgphp-0.7.0/src/Domain/Infra/DependencyInjection/Compiler/ResolveDomainPass.php000066400000000000000000000064361335536502400276720ustar00rootroot00000000000000 * * @internal */ final class ResolveDomainPass implements CompilerPassInterface { public function process(ContainerBuilder $container): void { $defaultEvents = array_values(array_filter(array_map(function (string $file): string { return 'MsgPhp\\Domain\\Event\\'.basename($file, '.php'); }, glob(\dirname(__DIR__, 3).'/Event/*Event.php')), function (string $class): bool { return !is_subclass_of($class, DomainEventInterface::class); })); $container->setParameter($param = 'msgphp.domain.events', $container->hasParameter($param) ? array_merge($container->getParameter($param), $defaultEvents) : $defaultEvents); if ($container->has(DomainMessageBusInterface::class)) { $commandBus = $container->findDefinition('msgphp.command_bus'); $commandBusId = null; $container->removeAlias('msgphp.command_bus'); foreach ($container->getDefinitions() as $id => $definition) { if ($definition === $commandBus) { $commandBusId = $id; break; } } foreach ($container->findTaggedServiceIds('msgphp.domain.command_handler') as $id => $attr) { ContainerHelper::tagCommandHandler($container, $id, explode(',', $attr[0]['handles']), (string) $commandBusId); } } else { foreach ($container->findTaggedServiceIds('msgphp.domain.message_aware') as $id => $attr) { $container->removeDefinition($id); } } $classMapping = $container->getParameter('msgphp.domain.class_mapping'); 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'); } } 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; } } msgphp-0.7.0/src/Domain/Infra/DependencyInjection/ConfigHelper.php000066400000000000000000000063121335536502400250600ustar00rootroot00000000000000 * * @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'] ?? self::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 $class => $features) { $available = isset($classMapping[$class]); $handlerAvailable = $available && is_subclass_of($classMapping[$class], DomainEventHandlerInterface::class); foreach ($features as $feature => $info) { if (!\is_array($info)) { $config += [$info => $available]; } else { $config += array_fill_keys($info, $available && self::uses($classMapping[$class], $feature) ? $handlerAvailable : false); } } } } 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.7.0/src/Domain/Infra/DependencyInjection/ContainerHelper.php000066400000000000000000000057551335536502400256070ustar00rootroot00000000000000 * * @internal */ final class ContainerHelper { private static $counter = 0; public static function hasBundle(ContainerInterface $container, string $class): bool { return \in_array($class, $container->getParameter('kernel.bundles'), true); } public static function getBundles(ContainerInterface $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, string &$id = null): Definition { $definition = $child ? new ChildDefinition($class) : new Definition($class); $definition->setPublic(false); return $container->setDefinition($id = $class.'.'.ContainerBuilder::hash(__METHOD__.++self::$counter), $definition); } public static function tagCommandHandler(ContainerBuilder $container, string $handlerId, array $handles, string $busId): void { $handler = $container->getDefinition($handlerId); $messengerEnabled = FeatureDetection::isMessengerAvailable($container); $simpleBusEnabled = FeatureDetection::hasSimpleBusCommandBusBundle($container); foreach ($handles as $class) { if ($messengerEnabled) { $handler->addTag('messenger.message_handler', ['handles' => $class, 'bus' => $busId]); } if ($simpleBusEnabled) { $handler ->setPublic(true) ->addTag('command_handler', ['handles' => $class]); } } } private function __construct() { } } msgphp-0.7.0/src/Domain/Infra/DependencyInjection/ExtensionHelper.php000066400000000000000000000167271335536502400256420ustar00rootroot00000000000000 * * @internal */ final class ExtensionHelper { public static function configureDomain(ContainerBuilder $container, array $classMapping, array $idClassMapping, array $identityMapping): void { foreach ($idClassMapping as $class => $idClass) { if (isset($classMapping[$class]) && !isset($idClassMapping[$classMapping[$class]])) { $idClassMapping[$classMapping[$class]] = $idClass; } } foreach ($identityMapping as $class => $mapping) { if (isset($classMapping[$class]) && !isset($identityMapping[$classMapping[$class]])) { $identityMapping[$classMapping[$class]] = $mapping; } } $container->setParameter($param = 'msgphp.domain.class_mapping', $container->hasParameter($param) ? $classMapping + $container->getParameter($param) : $classMapping); $container->setParameter($param = 'msgphp.domain.id_class_mapping', $container->hasParameter($param) ? $idClassMapping + $container->getParameter($param) : $idClassMapping); $container->setParameter($param = 'msgphp.domain.identity_mapping', $container->hasParameter($param) ? $identityMapping + $container->getParameter($param) : $identityMapping); } public static function configureDoctrineOrm(ContainerBuilder $container, array $classMapping, array $idTypeMapping, array $typeClassMapping, array $mappingFiles): void { $dbalTypes = $dbalMappingTypes = $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) { $dbalMappingTypes[$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]; } $container->setParameter($param = 'msgphp.doctrine.type_config', $container->hasParameter($param) ? $typeConfig + $container->getParameter($param) : $typeConfig); $container->setParameter($param = 'msgphp.doctrine.mapping_files', $container->hasParameter($param) ? array_merge($container->getParameter($param), $mappingFiles) : $mappingFiles); $container->prependExtensionConfig('doctrine', [ 'dbal' => [ 'types' => $dbalTypes, 'mapping_types' => $dbalMappingTypes, ], 'orm' => [ 'resolve_target_entities' => $classMapping, ], ]); } public static function finalizeCommandHandlers(ContainerBuilder $container, array $classMapping, array $commands, array $events): void { foreach ($container->findTaggedServiceIds($tag = 'msgphp.domain.command_handler') as $id => $attr) { $definition = $container->getDefinition($id); $definition->addTag('msgphp.domain.message_aware'); $command = (new \ReflectionMethod($definition->getClass() ?? (string) $id, '__invoke'))->getParameters()[0]->getClass()->getName(); if (empty($commands[$command])) { $container->removeDefinition($id); continue; } $handles = [$command]; if (isset($classMapping[$command])) { $handles[] = $classMapping[$command]; } $definition ->clearTag($tag) ->addTag($tag, $attr[0] + ['handles' => implode(',', $handles)]); } foreach ($events as $class) { if (isset($classMapping[$class])) { $events[] = $classMapping[$class]; } } $container->setParameter($param = 'msgphp.domain.events', $container->hasParameter($param) ? array_merge($container->getParameter($param), $events) : $events); } public static function finalizeDoctrineOrmRepositories(ContainerBuilder $container, array $classMapping, array $entityRepositoryMapping): void { foreach ($entityRepositoryMapping as $entity => $repository) { if (!$container->hasDefinition($repository)) { continue; } if (!isset($classMapping[$entity])) { $container->removeDefinition($repository); continue; } ($definition = $container->getDefinition($repository)) ->setArgument('$class', $classMapping[$entity]); foreach (class_implements($definition->getClass() ?? $repository) as $interface) { $container->setAlias($interface, new Alias($repository, false)); } } } public static function finalizeConsoleCommands(ContainerBuilder $container, array $commands, array $consoleDomainCommandsMapping): void { foreach ($consoleDomainCommandsMapping as $domainCommand => $consoleCommands) { foreach ($consoleCommands as $consoleCommand) { if (!$container->hasDefinition($consoleCommand)) { continue; } if (empty($commands[$domainCommand])) { $container->removeDefinition($consoleCommand); continue; } $container->getDefinition($consoleCommand) ->addTag('msgphp.domain.message_aware'); } } } public static function registerConsoleClassContextFactory(ContainerBuilder $container, string $class, int $flags = 0): Definition { $definition = ContainerHelper::registerAnonymous($container, ConsoleInfra\Context\ClassContextFactory::class, true) ->setArgument('$class', $class) ->setArgument('$flags', $flags); if (FeatureDetection::isDoctrineOrmAvailable($container)) { $definition = ContainerHelper::registerAnonymous($container, ConsoleInfra\Context\DoctrineEntityContextFactory::class) ->setArgument('$factory', $definition) ->setArgument('$em', new Reference('msgphp.doctrine.entity_manager')) ->setArgument('$class', $class); } return $definition; } private function __construct() { } } msgphp-0.7.0/src/Domain/Infra/DependencyInjection/FeatureDetection.php000066400000000000000000000065421335536502400257520ustar00rootroot00000000000000 * * @todo let user allow to opt-in / -out per feature pre-build * * @internal */ final class FeatureDetection { public static function isSymfonyFullStack(): bool { return class_exists('Symfony\Bundle\FullStack'); } public static function hasFrameworkBundle(ContainerInterface $container): bool { return ContainerHelper::hasBundle($container, FrameworkBundle::class); } public static function hasSecurityBundle(ContainerInterface $container): bool { return ContainerHelper::hasBundle($container, SecurityBundle::class); } public static function hasTwigBundle(ContainerInterface $container): bool { return ContainerHelper::hasBundle($container, TwigBundle::class); } public static function hasDoctrineBundle(ContainerInterface $container): bool { return ContainerHelper::hasBundle($container, DoctrineBundle::class); } public static function hasSimpleBusCommandBusBundle(ContainerInterface $container): bool { return ContainerHelper::hasBundle($container, SimpleBusCommandBusBundle::class); } public static function hasSimpleBusEventBusBundle(ContainerInterface $container): bool { return ContainerHelper::hasBundle($container, SimpleBusEventBusBundle::class); } public static function hasMsgPhpEavBundle(ContainerInterface $container): bool { return ContainerHelper::hasBundle($container, MsgPhpEavBundle::class); } public static function isFormAvailable(ContainerInterface $container): bool { return !self::isSymfonyFullStack() && self::hasFrameworkBundle($container) && interface_exists(FormInterface::class); } public static function isValidatorAvailable(ContainerInterface $container): bool { return !self::isSymfonyFullStack() && self::hasFrameworkBundle($container) && interface_exists(ValidatorInterface::class); } public static function isConsoleAvailable(ContainerInterface $container): bool { return !self::isSymfonyFullStack() && self::hasFrameworkBundle($container) && class_exists(ConsoleEvents::class); } public static function isMessengerAvailable(ContainerInterface $container): bool { return !self::isSymfonyFullStack() && self::hasFrameworkBundle($container) && interface_exists(MessageBusInterface::class); } public static function isDoctrineOrmAvailable(ContainerInterface $container): bool { return self::hasDoctrineBundle($container) && class_exists(DoctrineOrmVersion::class); } private function __construct() { } } msgphp-0.7.0/src/Domain/Infra/Doctrine/000077500000000000000000000000001335536502400176265ustar00rootroot00000000000000msgphp-0.7.0/src/Domain/Infra/Doctrine/DomainCollection.php000066400000000000000000000040351335536502400235640ustar00rootroot00000000000000 */ final class DomainCollection implements DomainCollectionInterface { private $collection; public static function fromValue(?iterable $value): DomainCollectionInterface { if ($value instanceof Collection) { return new self($value); } if ($value instanceof \Traversable) { $value = iterator_to_array($value); } return new self(new ArrayCollection($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.7.0/src/Domain/Infra/Doctrine/DomainEntityRepositoryTrait.php000066400000000000000000000150411335536502400260500ustar00rootroot00000000000000 */ 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.7.0/src/Domain/Infra/Doctrine/DomainIdType.php000066400000000000000000000071731335536502400226750ustar00rootroot00000000000000 */ 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.7.0/src/Domain/Infra/Doctrine/DomainIdentityMapping.php000066400000000000000000000031261335536502400245760ustar00rootroot00000000000000 */ 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; $factory = $this->em->getMetadataFactory(); if (!class_exists($class) || $factory->isTransient($class)) { throw InvalidClassException::create($class); } return $factory->getMetadataFor($class); } } msgphp-0.7.0/src/Domain/Infra/Doctrine/EntityAwareFactory.php000066400000000000000000000054011335536502400241230ustar00rootroot00000000000000 */ 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.7.0/src/Domain/Infra/Doctrine/Event/000077500000000000000000000000001335536502400207075ustar00rootroot00000000000000msgphp-0.7.0/src/Domain/Infra/Doctrine/Event/ObjectFieldMappingListener.php000066400000000000000000000106001335536502400266110ustar00rootroot00000000000000 */ final class ObjectFieldMappingListener { private $mappings; /** @var ClassMetadataFactory|null */ private $metadataFactory; public function __construct(array $mappings) { $this->mappings = $mappings; } public function loadClassMetadata(LoadClassMetadataEventArgs $event): void { if (!$this->mappings) { 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->mappings[$name = $class->getName()])) { $this->processFieldMapping($metadata, $this->mappings[$name]); } foreach ($class->getTraits() as $trait) { $this->processClassFields($metadata, $trait); } } private function processFieldMapping(ClassMetadataInfo $metadata, array $mapping): void { foreach ($mapping as $field => $info) { if ($metadata->hasField($field) || $metadata->hasAssociation($field)) { continue; } $info = ['fieldName' => $field] + $info; if (isset($info['type']) && method_exists($metadata, $method = 'map'.ucfirst($info['type']))) { unset($info['type']); $metadata->$method($info); if ('mapEmbedded' === $method) { $embeddableMetadata = $this->getMetadata($info['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($info); } } } 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 (!empty($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.7.0/src/Domain/Infra/Doctrine/Hydration/000077500000000000000000000000001335536502400215675ustar00rootroot00000000000000msgphp-0.7.0/src/Domain/Infra/Doctrine/Hydration/ScalarHydrator.php000066400000000000000000000014251335536502400252240ustar00rootroot00000000000000hydrateColumnInfo($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.7.0/src/Domain/Infra/Doctrine/Hydration/SingleScalarHydrator.php000066400000000000000000000014641335536502400263710ustar00rootroot00000000000000hydrateColumnInfo($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.7.0/src/Domain/Infra/Doctrine/MappingCacheWarmer.php000066400000000000000000000016171335536502400240410ustar00rootroot00000000000000 * * @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.7.0/src/Domain/Infra/Doctrine/ObjectFieldMappings.php000066400000000000000000000021461335536502400242130ustar00rootroot00000000000000 * * @internal */ final class ObjectFieldMappings implements ObjectFieldMappingsProviderInterface { public static function provideObjectFieldMappings(): iterable { yield Features\CanBeConfirmed::class => [ 'confirmationToken' => [ 'type' => 'string', 'unique' => true, 'nullable' => true, ], 'confirmedAt' => [ 'type' => 'datetime', 'nullable' => true, ], ]; yield Fields\CreatedAtField::class => [ 'createdAt' => [ 'type' => 'datetime', ], ]; yield Fields\EnabledField::class => [ 'enabled' => [ 'type' => 'boolean', ], ]; yield Fields\LastUpdatedAtField::class => [ 'lastUpdatedAt' => [ 'type' => 'datetime', ], ]; } } msgphp-0.7.0/src/Domain/Infra/Doctrine/ObjectFieldMappingsProviderInterface.php000066400000000000000000000007611335536502400275500ustar00rootroot00000000000000 */ interface ObjectFieldMappingsProviderInterface { 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 provideObjectFieldMappings(): iterable; } msgphp-0.7.0/src/Domain/Infra/Elasticsearch/000077500000000000000000000000001335536502400206315ustar00rootroot00000000000000msgphp-0.7.0/src/Domain/Infra/Elasticsearch/DocumentMappingProviderInterface.php000066400000000000000000000003751335536502400277750ustar00rootroot00000000000000 */ interface DocumentMappingProviderInterface { public static function provideDocumentMappings(): iterable; } msgphp-0.7.0/src/Domain/Infra/Elasticsearch/ProjectionRepository.php000066400000000000000000000057271335536502400255710ustar00rootroot00000000000000 */ final class ProjectionRepository implements ProjectionRepositoryInterface { private $client; private $index; public function __construct(Client $client, string $index) { $this->client = $client; $this->index = $index; } /** * @return PaginatedDomainCollectionInterface|ProjectionDocument[] */ public function findAll(string $type, int $offset = 0, int $limit = 0): PaginatedDomainCollectionInterface { $params = [ 'index' => $this->index, 'type' => $type, 'body' => [ 'from' => $offset, 'query' => ['match_all' => new \stdClass()], ], ]; if ($limit) { $params['body']['size'] = $limit; } $result = $this->client->search($params); $documents = $result['hits']['hits'] ?? []; $count = \count($documents); $totalCount = $result['hits']['total'] ?? $count; return new PaginatedDomainCollection((function () use ($documents) { foreach ($documents as $document) { yield $this->createDocument($document); } })(), (float) $offset, (float) $limit, (float) $count, (float) $totalCount); } public function find(string $type, string $id): ?ProjectionDocument { try { $document = $this->client->get([ 'index' => $this->index, 'type' => $type, 'id' => $id, ]); } catch (Missing404Exception $e) { return null; } return $this->createDocument($document); } public function clear(string $type): void { $this->client->deleteByQuery([ 'index' => $this->index, 'type' => $type, 'body' => [ 'query' => ['match_all' => new \stdClass()], ], ]); } public function save(ProjectionDocument $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, ]); } private function createDocument(array $data): ProjectionDocument { return new ProjectionDocument($data['_type'] ?? null, $data['_id'] ?? null, $data['_source'] ?? []); } } msgphp-0.7.0/src/Domain/Infra/Elasticsearch/ProjectionTypeRegistry.php000066400000000000000000000064001335536502400260510ustar00rootroot00000000000000 */ final class ProjectionTypeRegistry implements ProjectionTypeRegistryInterface { 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.7.0/src/Domain/Infra/InMemory/000077500000000000000000000000001335536502400176165ustar00rootroot00000000000000msgphp-0.7.0/src/Domain/Infra/InMemory/DomainEntityRepositoryTrait.php000066400000000000000000000123301335536502400260360ustar00rootroot00000000000000 */ 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)) { $value = array_map(function ($v) { return $this->identityHelper->normalizeIdentifier($v); }, $value); if (null === $knownValue || !\in_array($knownValue, $value)) { 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.7.0/src/Domain/Infra/InMemory/DomainIdentityMapping.php000066400000000000000000000030651335536502400245700ustar00rootroot00000000000000 */ 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.7.0/src/Domain/Infra/InMemory/GlobalObjectMemory.php000066400000000000000000000021551335536502400240520ustar00rootroot00000000000000storage = 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.7.0/src/Domain/Infra/InMemory/ObjectFieldAccessor.php000066400000000000000000000022111335536502400241600ustar00rootroot00000000000000accessor = $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.7.0/src/Domain/Infra/Messenger/000077500000000000000000000000001335536502400200075ustar00rootroot00000000000000msgphp-0.7.0/src/Domain/Infra/Messenger/DomainMessageBus.php000066400000000000000000000010221335536502400237010ustar00rootroot00000000000000 */ 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.7.0/src/Domain/Infra/Messenger/Middleware/000077500000000000000000000000001335536502400220645ustar00rootroot00000000000000msgphp-0.7.0/src/Domain/Infra/Messenger/Middleware/ConsoleMessageReceiverMiddleware.php000066400000000000000000000011521335536502400311660ustar00rootroot00000000000000 */ final class ConsoleMessageReceiverMiddleware implements MiddlewareInterface { private $receiver; public function __construct(MessageReceiver $receiver) { $this->receiver = $receiver; } public function handle($message, callable $next) { $this->receiver->receive($message); return $next($message); } } msgphp-0.7.0/src/Domain/Infra/SimpleBus/000077500000000000000000000000001335536502400177625ustar00rootroot00000000000000msgphp-0.7.0/src/Domain/Infra/SimpleBus/DomainMessageBus.php000066400000000000000000000010071335536502400236570ustar00rootroot00000000000000 */ 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.7.0/src/Domain/Infra/SimpleBus/Middleware/000077500000000000000000000000001335536502400220375ustar00rootroot00000000000000msgphp-0.7.0/src/Domain/Infra/SimpleBus/Middleware/ConsoleMessageReceiverMiddleware.php000066400000000000000000000011451335536502400311430ustar00rootroot00000000000000 */ 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.7.0/src/Domain/Infra/Uuid/000077500000000000000000000000001335536502400167655ustar00rootroot00000000000000msgphp-0.7.0/src/Domain/Infra/Uuid/DomainId.php000066400000000000000000000027571335536502400211750ustar00rootroot00000000000000 */ class DomainId implements DomainIdInterface { private $uuid; /** * @return static */ 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.7.0/src/Domain/LICENSE000066400000000000000000000020601335536502400160230ustar00rootroot00000000000000MIT 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.7.0/src/Domain/Message/000077500000000000000000000000001335536502400164045ustar00rootroot00000000000000msgphp-0.7.0/src/Domain/Message/DomainMessageBus.php000066400000000000000000000014251335536502400223050ustar00rootroot00000000000000 */ final class DomainMessageBus implements DomainMessageBusInterface { private $commandBus; private $eventBus; private $eventClasses; public function __construct(DomainMessageBusInterface $commandBus, DomainMessageBusInterface $eventBus, array $eventClasses) { $this->commandBus = $commandBus; $this->eventBus = $eventBus; $this->eventClasses = array_flip($eventClasses); } public function dispatch($message) { if (isset($this->eventClasses[\get_class($message)])) { return $this->eventBus->dispatch($message); } return $this->commandBus->dispatch($message); } } msgphp-0.7.0/src/Domain/Message/DomainMessageBusInterface.php000066400000000000000000000004001335536502400241160ustar00rootroot00000000000000 */ interface DomainMessageBusInterface { /** * @param object $message */ public function dispatch($message); } msgphp-0.7.0/src/Domain/Message/MessageDispatchingTrait.php000066400000000000000000000011251335536502400236620ustar00rootroot00000000000000 */ 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.7.0/src/Domain/Message/MessageReceivingInterface.php000066400000000000000000000004171335536502400241600ustar00rootroot00000000000000 */ interface MessageReceivingInterface { /** * @param object $message */ public function onMessageReceived($message): void; } msgphp-0.7.0/src/Domain/PaginatedDomainCollection.php000066400000000000000000000053731335536502400226010ustar00rootroot00000000000000 */ final class PaginatedDomainCollection implements PaginatedDomainCollectionInterface { private $collection; private $offset; private $limit; private $count; private $totalCount; public static function fromValue(?iterable $value): DomainCollectionInterface { return new self($value ?? []); } public function __construct(iterable $elements, float $offset = .0, float $limit = .0, float $count = null, float $totalCount = null) { if (null !== $count) { $count = (int) $count; } $this->collection = $elements instanceof DomainCollectionInterface ? $elements : DomainCollection::fromValue($elements); $this->offset = $offset; $this->limit = $limit; $this->count = $count; $this->totalCount = $totalCount; } public function getIterator(): \Traversable { return $this->collection->getIterator(); } 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 $this->collection->filter($filter); } public function slice(int $offset, int $limit = 0): DomainCollectionInterface { return $this->collection->slice($offset, $limit); } public function map(callable $mapper): array { return $this->collection->map($mapper); } public function count(): int { return $this->count ?? $this->count = \count($this->collection); } public function getOffset(): float { return $this->offset; } public function getLimit(): float { return $this->limit; } public function getCurrentPage(): float { if (0 >= $this->limit) { return 1.; } return floor($this->offset / $this->limit) + 1.; } public function getLastPage(): float { if (0 >= $this->limit) { return 1.; } return ceil($this->getTotalCount() / $this->limit) ?: 1.; } public function getTotalCount(): float { return $this->totalCount ?? $this->totalCount = (float) \count($this); } } msgphp-0.7.0/src/Domain/PaginatedDomainCollectionInterface.php000066400000000000000000000006431335536502400244150ustar00rootroot00000000000000 */ interface PaginatedDomainCollectionInterface extends DomainCollectionInterface { public function getOffset(): float; public function getLimit(): float; public function getCurrentPage(): float; public function getLastPage(): float; public function getTotalCount(): float; } msgphp-0.7.0/src/Domain/Projection/000077500000000000000000000000001335536502400171345ustar00rootroot00000000000000msgphp-0.7.0/src/Domain/Projection/ProjectionDocument.php000066400000000000000000000026551335536502400234700ustar00rootroot00000000000000 */ final class ProjectionDocument { 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 { return $this->type; } public function getId(): ?string { return $this->id; } public function getBody(): array { return $this->body; } public function toProjection(): ProjectionInterface { if (null === $this->type) { throw new \LogicException('Document type not set.'); } if (!is_subclass_of($this->type, ProjectionInterface::class)) { throw new \LogicException(sprintf('Document type must be a sub class of "%s", got "%s".', ProjectionInterface::class, $this->type)); } return $this->type::fromDocument($this->body); } } msgphp-0.7.0/src/Domain/Projection/ProjectionDocumentProvider.php000066400000000000000000000021771335536502400252020ustar00rootroot00000000000000 */ final class ProjectionDocumentProvider implements \IteratorAggregate { private $transformer; private $dataProviders; /** * @param callable[] $dataProviders */ public function __construct(ProjectionDocumentTransformerInterface $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 ProjectionDocument(); $document->status = ProjectionDocument::STATUS_FAILED_TRANSFORMATION; $document->source = $object; $document->error = $e; } yield $document; } } } } msgphp-0.7.0/src/Domain/Projection/ProjectionDocumentTransformerInterface.php000066400000000000000000000004431335536502400275250ustar00rootroot00000000000000 */ interface ProjectionDocumentTransformerInterface { /** * @param object $object */ public function transform($object): ProjectionDocument; } msgphp-0.7.0/src/Domain/Projection/ProjectionInterface.php000066400000000000000000000003471335536502400236060ustar00rootroot00000000000000 */ interface ProjectionInterface { public static function fromDocument(array $document): self; } msgphp-0.7.0/src/Domain/Projection/ProjectionRepositoryInterface.php000066400000000000000000000012451335536502400257040ustar00rootroot00000000000000 */ interface ProjectionRepositoryInterface { /** * @return PaginatedDomainCollectionInterface|ProjectionDocument[] */ public function findAll(string $type, int $offset = 0, int $limit = 0): PaginatedDomainCollectionInterface; public function find(string $type, string $id): ?ProjectionDocument; public function clear(string $type): void; public function save(ProjectionDocument $document): void; public function delete(string $type, string $id): void; } msgphp-0.7.0/src/Domain/Projection/ProjectionSynchronization.php000066400000000000000000000025451335536502400251110ustar00rootroot00000000000000 */ final class ProjectionSynchronization { private $typeRegistry; private $repository; private $documentProvider; /** * @param ProjectionDocument[] $documentProvider */ public function __construct(ProjectionTypeRegistryInterface $typeRegistry, ProjectionRepositoryInterface $repository, iterable $documentProvider) { $this->typeRegistry = $typeRegistry; $this->repository = $repository; $this->documentProvider = $documentProvider; } /** * @return ProjectionDocument[] */ public function synchronize(): iterable { foreach ($this->typeRegistry->all() as $type) { $this->repository->clear($type); } foreach ($this->documentProvider as $document) { if (ProjectionDocument::STATUS_UNKNOWN !== $document->status) { continue; } try { $document->status = ProjectionDocument::STATUS_SYNCHRONIZED; $this->repository->save($document); } catch (\Throwable $e) { $document->status = ProjectionDocument::STATUS_FAILED_SAVING; $document->error = $e; } yield $document; } } } msgphp-0.7.0/src/Domain/Projection/ProjectionTypeRegistryInterface.php000066400000000000000000000005141335536502400261750ustar00rootroot00000000000000 */ interface ProjectionTypeRegistryInterface { /** * @return string[] */ public function all(): array; public function initialize(): void; public function destroy(): void; } msgphp-0.7.0/src/Domain/README.md000066400000000000000000000040051335536502400162760ustar00rootroot00000000000000# 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 - Projection document model - Common infrastructure ## Blog Posts - [Domain-driven-design: Projections in practice with API Platform and Elasticsearch](https://medium.com/@ro0NL/domain-driven-design-projections-in-practice-with-api-platform-and-elasticsearch-c785ed6d660b) - [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.7.0/src/Domain/composer.json000066400000000000000000000030151335536502400175410ustar00rootroot00000000000000{ "name": "msgphp/domain", "type": "library", "license": "MIT", "description": "A base domain layer to rapidly built other domain layers", "keywords": ["domain-driven-design", "ddd", "domain model", "rich domain model", "entity", "event sourcing", "es", "command query responsibility segregation", "cqrs"], "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.16|^4.0.16|^4.1.5", "symfony/http-kernel": "^3.4|^4.0", "symfony/messenger": "^4.1", "symfony/phpunit-bridge": "^3.4.9|^4.0.9", "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": "0.7-dev" } } } msgphp-0.7.0/src/Eav/000077500000000000000000000000001335536502400143245ustar00rootroot00000000000000msgphp-0.7.0/src/Eav/.gitattributes000066400000000000000000000000641335536502400172170ustar00rootroot00000000000000Tests/ export-ignore phpunit.xml.dist export-ignore msgphp-0.7.0/src/Eav/.gitignore000066400000000000000000000000471335536502400163150ustar00rootroot00000000000000/composer.lock /composer.phar /vendor/ msgphp-0.7.0/src/Eav/AttributeId.php000066400000000000000000000003411335536502400172530ustar00rootroot00000000000000 */ final class AttributeId extends DomainId implements AttributeIdInterface { } msgphp-0.7.0/src/Eav/AttributeIdInterface.php000066400000000000000000000003321335536502400210740ustar00rootroot00000000000000 */ interface AttributeIdInterface extends DomainIdInterface { } msgphp-0.7.0/src/Eav/AttributeValueId.php000066400000000000000000000003531335536502400202530ustar00rootroot00000000000000 */ final class AttributeValueId extends DomainId implements AttributeValueIdInterface { } msgphp-0.7.0/src/Eav/AttributeValueIdInterface.php000066400000000000000000000003371335536502400220760ustar00rootroot00000000000000 */ interface AttributeValueIdInterface extends DomainIdInterface { } msgphp-0.7.0/src/Eav/Command/000077500000000000000000000000001335536502400157025ustar00rootroot00000000000000msgphp-0.7.0/src/Eav/Command/CreateAttributeCommand.php000066400000000000000000000004331335536502400230010ustar00rootroot00000000000000 */ class CreateAttributeCommand { public $context; final public function __construct(array $context) { $this->context = $context; } } msgphp-0.7.0/src/Eav/Command/DeleteAttributeCommand.php000066400000000000000000000004451335536502400230030ustar00rootroot00000000000000 */ class DeleteAttributeCommand { public $attributeId; final public function __construct($attributeId) { $this->attributeId = $attributeId; } } msgphp-0.7.0/src/Eav/Command/Handler/000077500000000000000000000000001335536502400172575ustar00rootroot00000000000000msgphp-0.7.0/src/Eav/Command/Handler/CreateAttributeHandler.php000066400000000000000000000021741335536502400243610ustar00rootroot00000000000000 */ 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.7.0/src/Eav/Command/Handler/DeleteAttributeHandler.php000066400000000000000000000023641335536502400243610ustar00rootroot00000000000000 */ 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.7.0/src/Eav/Entity/000077500000000000000000000000001335536502400156005ustar00rootroot00000000000000msgphp-0.7.0/src/Eav/Entity/Attribute.php000066400000000000000000000003751335536502400202610ustar00rootroot00000000000000 */ abstract class Attribute { abstract public function getId(): AttributeIdInterface; } msgphp-0.7.0/src/Eav/Entity/AttributeValue.php000066400000000000000000000052071335536502400212550ustar00rootroot00000000000000 */ abstract class AttributeValue { private $attribute; private $boolValue; private $intValue; private $floatValue; private $stringValue; private $dateTimeValue; private $checksum; private $value; private $isNull; public static function getChecksum($value): string { return md5(serialize([\gettype($value), static::prepareChecksumValue($value)])); } 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(); } final public function getValue() { if ($this->isNull) { return null; } if (null !== $this->value) { return $this->value; } if (null === $value = $this->doGetValue()) { $this->isNull = true; } return $this->value = $value; } final public function changeValue($value): void { $this->doClearValue(); $this->isNull = null === $value; if (!$this->isNull) { $this->doSetValue($value); } $this->value = $value; $this->checksum = static::getChecksum($value); } protected static function prepareChecksumValue($value) { return $value; } protected function doClearValue(): void { $this->boolValue = $this->intValue = $this->floatValue = $this->stringValue = $this->dateTimeValue = null; } 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.7.0/src/Eav/Entity/Features/000077500000000000000000000000001335536502400173565ustar00rootroot00000000000000msgphp-0.7.0/src/Eav/Entity/Features/EntityAttributeValue.php000066400000000000000000000016111335536502400242230ustar00rootroot00000000000000 */ 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.7.0/src/Eav/Entity/Fields/000077500000000000000000000000001335536502400170065ustar00rootroot00000000000000msgphp-0.7.0/src/Eav/Entity/Fields/AttributesField.php000066400000000000000000000017751335536502400226230ustar00rootroot00000000000000 */ 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.7.0/src/Eav/Event/000077500000000000000000000000001335536502400154055ustar00rootroot00000000000000msgphp-0.7.0/src/Eav/Event/AttributeCreatedEvent.php000066400000000000000000000005061335536502400223540ustar00rootroot00000000000000 */ class AttributeCreatedEvent { public $attribute; final public function __construct(Attribute $attribute) { $this->attribute = $attribute; } } msgphp-0.7.0/src/Eav/Event/AttributeDeletedEvent.php000066400000000000000000000005061335536502400223530ustar00rootroot00000000000000 */ class AttributeDeletedEvent { public $attribute; final public function __construct(Attribute $attribute) { $this->attribute = $attribute; } } msgphp-0.7.0/src/Eav/Infra/000077500000000000000000000000001335536502400153635ustar00rootroot00000000000000msgphp-0.7.0/src/Eav/Infra/Doctrine/000077500000000000000000000000001335536502400171325ustar00rootroot00000000000000msgphp-0.7.0/src/Eav/Infra/Doctrine/ObjectFieldMappings.php000066400000000000000000000014601335536502400235150ustar00rootroot00000000000000 * * @internal */ final class ObjectFieldMappings implements ObjectFieldMappingsProviderInterface { public static function provideObjectFieldMappings(): iterable { yield Features\EntityAttributeValue::class => [ 'attributeValue' => [ 'type' => self::TYPE_ONE_TO_ONE, 'targetEntity' => AttributeValue::class, 'cascade' => ['all'], 'joinColumns' => [ ['nullable' => false, 'onDelete' => 'CASCADE'], ], ], ]; } } msgphp-0.7.0/src/Eav/Infra/Doctrine/Repository/000077500000000000000000000000001335536502400213115ustar00rootroot00000000000000msgphp-0.7.0/src/Eav/Infra/Doctrine/Repository/AttributeRepository.php000066400000000000000000000022241335536502400260650ustar00rootroot00000000000000 */ 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.7.0/src/Eav/Infra/Doctrine/Repository/EntityAttributeValueRepositoryTrait.php000066400000000000000000000027271335536502400312730ustar00rootroot00000000000000 */ trait EntityAttributeValueRepositoryTrait { use DomainEntityRepositoryTrait; private function addAttributeCriteria(QueryBuilder $qb, AttributeIdInterface $attributeId, $value = null): void { $field = $this->alias.'.'.$this->attributeValueField; $targetClass = $this->em->getClassMetadata($this->class)->getAssociationMapping($this->attributeValueField)['targetEntity']; if (!is_subclass_of($targetClass, AttributeValue::class)) { throw new \LogicException(sprintf('The field "%s" is expected to be an association mapping for "%s", got "%s".', $this->class.'.'.$this->attributeValueField, AttributeValue::class, $targetClass)); } if (3 === \func_num_args()) { $qb->join($field, 'attribute_value', Join::WITH, 'attribute_value.checksum = '.$this->addFieldParameter($qb, $this->attributeValueField, $targetClass::getChecksum($value))); } else { $qb->join($field, 'attribute_value'); } $qb->join('attribute_value.attribute', 'attribute', Join::WITH, 'attribute.id = '.$this->addFieldParameter($qb, 'attribute', $attributeId)); } } msgphp-0.7.0/src/Eav/Infra/Doctrine/Resources/000077500000000000000000000000001335536502400211045ustar00rootroot00000000000000msgphp-0.7.0/src/Eav/Infra/Doctrine/Resources/dist-mapping/000077500000000000000000000000001335536502400235005ustar00rootroot00000000000000msgphp-0.7.0/src/Eav/Infra/Doctrine/Resources/dist-mapping/Eav.Entity.Attribute.orm.xml000066400000000000000000000006271335536502400307530ustar00rootroot00000000000000 msgphp-0.7.0/src/Eav/Infra/Doctrine/Resources/dist-mapping/Eav.Entity.AttributeValue.orm.xml000066400000000000000000000017161335536502400317500ustar00rootroot00000000000000 msgphp-0.7.0/src/Eav/Infra/Doctrine/Type/000077500000000000000000000000001335536502400200535ustar00rootroot00000000000000msgphp-0.7.0/src/Eav/Infra/Doctrine/Type/AttributeIdType.php000066400000000000000000000004371335536502400236520ustar00rootroot00000000000000 */ final class AttributeIdType extends DomainIdType { public const NAME = 'msgphp_attribute_id'; } msgphp-0.7.0/src/Eav/Infra/Doctrine/Type/AttributeValueIdType.php000066400000000000000000000004521335536502400246440ustar00rootroot00000000000000 */ final class AttributeValueIdType extends DomainIdType { public const NAME = 'msgphp_attribute_value_id'; } msgphp-0.7.0/src/Eav/Infra/Uuid/000077500000000000000000000000001335536502400162715ustar00rootroot00000000000000msgphp-0.7.0/src/Eav/Infra/Uuid/AttributeId.php000066400000000000000000000004341335536502400212230ustar00rootroot00000000000000 */ final class AttributeId extends DomainId implements AttributeIdInterface { } msgphp-0.7.0/src/Eav/Infra/Uuid/AttributeValueId.php000066400000000000000000000004531335536502400222210ustar00rootroot00000000000000 */ final class AttributeValueId extends DomainId implements AttributeValueIdInterface { } msgphp-0.7.0/src/Eav/LICENSE000066400000000000000000000020601335536502400153270ustar00rootroot00000000000000MIT 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.7.0/src/Eav/README.md000066400000000000000000000024701335536502400156060ustar00rootroot00000000000000# Entity-Attribute-Value Domain 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 - Symfony messenger commands & events - Doctrine persistence - Default 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.7.0/src/Eav/Repository/000077500000000000000000000000001335536502400165035ustar00rootroot00000000000000msgphp-0.7.0/src/Eav/Repository/AttributeRepositoryInterface.php000066400000000000000000000012541335536502400251020ustar00rootroot00000000000000 */ 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.7.0/src/Eav/composer.json000066400000000000000000000017031335536502400170470ustar00rootroot00000000000000{ "name": "msgphp/eav", "type": "library", "license": "MIT", "description": "A domain layer providing basic EAV management", "keywords": ["rich domain model", "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.7" }, "require-dev": { "doctrine/orm": "^2.6", "ramsey/uuid": "^3.7", "symfony/phpunit-bridge": "^3.4.9|^4.0.9", "symfony/var-dumper": "^3.4|^4.0" }, "config": { "preferred-install": { "*": "dist" }, "sort-packages": true }, "extra": { "branch-alias": { "dev-master": "0.7-dev" } } } msgphp-0.7.0/src/EavBundle/000077500000000000000000000000001335536502400154565ustar00rootroot00000000000000msgphp-0.7.0/src/EavBundle/.gitattributes000066400000000000000000000000641335536502400203510ustar00rootroot00000000000000Tests/ export-ignore phpunit.xml.dist export-ignore msgphp-0.7.0/src/EavBundle/.gitignore000066400000000000000000000000471335536502400174470ustar00rootroot00000000000000/composer.lock /composer.phar /vendor/ msgphp-0.7.0/src/EavBundle/DependencyInjection/000077500000000000000000000000001335536502400213775ustar00rootroot00000000000000msgphp-0.7.0/src/EavBundle/DependencyInjection/Compiler/000077500000000000000000000000001335536502400231515ustar00rootroot00000000000000msgphp-0.7.0/src/EavBundle/DependencyInjection/Compiler/CleanupPass.php000066400000000000000000000014201335536502400260750ustar00rootroot00000000000000 * * @internal */ final class CleanupPass implements CompilerPassInterface { public function process(ContainerBuilder $container): void { ContainerHelper::removeIf($container, !$container->has(Repository\AttributeRepositoryInterface::class), [ Command\Handler\CreateAttributeHandler::class, Command\Handler\DeleteAttributeHandler::class, ]); } } msgphp-0.7.0/src/EavBundle/DependencyInjection/Configuration.php000066400000000000000000000067471335536502400247350ustar00rootroot00000000000000 * * @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, ]; public const DOCTRINE_TYPE_MAPPING = [ AttributeIdInterface::class => DoctrineInfra\Type\AttributeIdType::class, AttributeValueIdInterface::class => DoctrineInfra\Type\AttributeValueIdType::class, ]; public const DOCTRINE_REPOSITORY_MAPPING = [ Entity\Attribute::class => DoctrineInfra\Repository\AttributeRepository::class, ]; public const CONSOLE_COMMAND_MAPPING = []; private const COMMAND_MAPPING = [ Entity\Attribute::class => [ Command\CreateAttributeCommand::class => true, Command\DeleteAttributeCommand::class => true, ], ]; private static $packageDir; public static function getPackageDir(): string { return self::$packageDir ?? (self::$packageDir = \dirname((string) (new \ReflectionClass(AttributeIdInterface::class))->getFileName())); } 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.7.0/src/EavBundle/DependencyInjection/Extension.php000066400000000000000000000064361335536502400240750ustar00rootroot00000000000000 * * @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); ExtensionHelper::configureDomain($container, $config['class_mapping'], Configuration::AGGREGATE_ROOTS, Configuration::IDENTITY_MAPPING); // message infra $loader->load('message.php'); ExtensionHelper::finalizeCommandHandlers($container, $config['class_mapping'], $config['commands'], array_map(function (string $file): string { return 'MsgPhp\\Eav\\Event\\'.basename($file, '.php'); }, glob(Configuration::getPackageDir().'/Event/*Event.php'))); // persistence infra if (FeatureDetection::isDoctrineOrmAvailable($container)) { $this->loadDoctrineOrm($config, $loader, $container); } } public function prepend(ContainerBuilder $container): void { $config = $this->processConfiguration($this->getConfiguration($configs = $container->getExtensionConfig($this->getAlias()), $container), $configs); if (FeatureDetection::isDoctrineOrmAvailable($container)) { ExtensionHelper::configureDoctrineOrm( $container, $config['class_mapping'], $config['id_type_mapping'], Configuration::DOCTRINE_TYPE_MAPPING, self::getDoctrineMappingFiles($config, $container) ); } } public function process(ContainerBuilder $container): void { } private static function getDoctrineMappingFiles(array $config, ContainerBuilder $container): array { $baseDir = Configuration::getPackageDir().'/Infra/Doctrine/Resources/dist-mapping'; return glob($baseDir.'/*.orm.xml'); } private function loadDoctrineOrm(array $config, LoaderInterface $loader, ContainerBuilder $container): void { $loader->load('doctrine.php'); ExtensionHelper::finalizeDoctrineOrmRepositories($container, $config['class_mapping'], Configuration::DOCTRINE_REPOSITORY_MAPPING); } } msgphp-0.7.0/src/EavBundle/LICENSE000066400000000000000000000020601335536502400164610ustar00rootroot00000000000000MIT 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.7.0/src/EavBundle/MsgPhpEavBundle.php000066400000000000000000000017551335536502400211630ustar00rootroot00000000000000 */ 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::build($container); } public function getContainerExtension(): ?ExtensionInterface { return new Extension(); } } msgphp-0.7.0/src/EavBundle/README.md000066400000000000000000000035471335536502400167460ustar00rootroot00000000000000# 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 - Symfony messenger commands & events - Doctrine persistence - Default 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. ## 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.7.0/src/EavBundle/Resources/000077500000000000000000000000001335536502400174305ustar00rootroot00000000000000msgphp-0.7.0/src/EavBundle/Resources/config/000077500000000000000000000000001335536502400206755ustar00rootroot00000000000000msgphp-0.7.0/src/EavBundle/Resources/config/doctrine.php000066400000000000000000000015211335536502400232140ustar00rootroot00000000000000services() ->defaults() ->autowire() ->private() ->load('MsgPhp\\Eav\\Infra\\Doctrine\\Repository\\', Configuration::getPackageDir().'/Infra/Doctrine/Repository/*Repository.php') ->bind(EntityManagerInterface::class, ref('msgphp.doctrine.entity_manager')) ->set(Doctrine\ObjectFieldMappings::class) ->tag('msgphp.doctrine.object_field_mappings', ['priority' => -100]) ; }; msgphp-0.7.0/src/EavBundle/Resources/config/message.php000066400000000000000000000007721335536502400230400ustar00rootroot00000000000000services() ->defaults() ->autowire() ->private() ->load('MsgPhp\\Eav\\Command\\Handler\\', Configuration::getPackageDir().'/Command/Handler/*Handler.php') ->tag('msgphp.domain.command_handler') ; }; msgphp-0.7.0/src/EavBundle/composer.json000066400000000000000000000022011335536502400201730ustar00rootroot00000000000000{ "name": "msgphp/eav-bundle", "type": "symfony-bundle", "license": "MIT", "description": "Basic entity-attribute-value management (the `EAV` domain)", "keywords": ["rich domain model", "symfony", "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.7", "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.9|^4.0.9", "symfony/var-dumper": "^3.4|^4.0" }, "config": { "preferred-install": { "*": "dist" }, "sort-packages": true }, "extra": { "branch-alias": { "dev-master": "0.7-dev" } } } msgphp-0.7.0/src/User/000077500000000000000000000000001335536502400145275ustar00rootroot00000000000000msgphp-0.7.0/src/User/.gitattributes000066400000000000000000000000641335536502400174220ustar00rootroot00000000000000Tests/ export-ignore phpunit.xml.dist export-ignore msgphp-0.7.0/src/User/.gitignore000066400000000000000000000000471335536502400165200ustar00rootroot00000000000000/composer.lock /composer.phar /vendor/ msgphp-0.7.0/src/User/Command/000077500000000000000000000000001335536502400161055ustar00rootroot00000000000000msgphp-0.7.0/src/User/Command/AddUserAttributeValueCommand.php000066400000000000000000000007611335536502400243310ustar00rootroot00000000000000 */ 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.7.0/src/User/Command/AddUserEmailCommand.php000066400000000000000000000006351335536502400224200ustar00rootroot00000000000000 */ 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.7.0/src/User/Command/AddUserRoleCommand.php000066400000000000000000000006501335536502400222670ustar00rootroot00000000000000 */ 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.7.0/src/User/Command/ChangeUserAttributeValueCommand.php000066400000000000000000000005051335536502400250220ustar00rootroot00000000000000 */ class ChangeUserAttributeValueCommand { public $id; public $value; final public function __construct($id, $value) { $this->id = $id; $this->value = $value; } } msgphp-0.7.0/src/User/Command/ChangeUserCredentialCommand.php000066400000000000000000000005371335536502400241410ustar00rootroot00000000000000 */ class ChangeUserCredentialCommand { public $userId; public $context; final public function __construct($userId, array $context) { $this->userId = $userId; $this->context = $context; } } msgphp-0.7.0/src/User/Command/ConfirmUserCommand.php000066400000000000000000000004161335536502400223520ustar00rootroot00000000000000 */ class ConfirmUserCommand { public $userId; final public function __construct($userId) { $this->userId = $userId; } } msgphp-0.7.0/src/User/Command/ConfirmUserEmailCommand.php000066400000000000000000000004261335536502400233230ustar00rootroot00000000000000 */ class ConfirmUserEmailCommand { public $email; final public function __construct(string $email) { $this->email = $email; } } msgphp-0.7.0/src/User/Command/CreateRoleCommand.php000066400000000000000000000004271335536502400221450ustar00rootroot00000000000000 */ class CreateRoleCommand { public $context; final public function __construct(array $context) { $this->context = $context; } } msgphp-0.7.0/src/User/Command/CreateUserCommand.php000066400000000000000000000004271335536502400221620ustar00rootroot00000000000000 */ class CreateUserCommand { public $context; final public function __construct(array $context) { $this->context = $context; } } msgphp-0.7.0/src/User/Command/DeleteRoleCommand.php000066400000000000000000000004341335536502400221420ustar00rootroot00000000000000 */ class DeleteRoleCommand { public $roleName; final public function __construct(string $roleName) { $this->roleName = $roleName; } } msgphp-0.7.0/src/User/Command/DeleteUserAttributeValueCommand.php000066400000000000000000000004131335536502400250350ustar00rootroot00000000000000 */ class DeleteUserAttributeValueCommand { public $id; final public function __construct($id) { $this->id = $id; } } msgphp-0.7.0/src/User/Command/DeleteUserCommand.php000066400000000000000000000004151335536502400221560ustar00rootroot00000000000000 */ class DeleteUserCommand { public $userId; final public function __construct($userId) { $this->userId = $userId; } } msgphp-0.7.0/src/User/Command/DeleteUserEmailCommand.php000066400000000000000000000004251335536502400231270ustar00rootroot00000000000000 */ class DeleteUserEmailCommand { public $email; final public function __construct(string $email) { $this->email = $email; } } msgphp-0.7.0/src/User/Command/DeleteUserRoleCommand.php000066400000000000000000000005361335536502400230040ustar00rootroot00000000000000 */ class DeleteUserRoleCommand { public $userId; public $roleName; final public function __construct($userId, string $roleName) { $this->userId = $userId; $this->roleName = $roleName; } } msgphp-0.7.0/src/User/Command/DisableUserCommand.php000066400000000000000000000004161335536502400223200ustar00rootroot00000000000000 */ class DisableUserCommand { public $userId; final public function __construct($userId) { $this->userId = $userId; } } msgphp-0.7.0/src/User/Command/EnableUserCommand.php000066400000000000000000000004151335536502400221420ustar00rootroot00000000000000 */ class EnableUserCommand { public $userId; final public function __construct($userId) { $this->userId = $userId; } } msgphp-0.7.0/src/User/Command/Handler/000077500000000000000000000000001335536502400174625ustar00rootroot00000000000000msgphp-0.7.0/src/User/Command/Handler/AddUserAttributeValueHandler.php000066400000000000000000000034771335536502400257140ustar00rootroot00000000000000 */ 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.7.0/src/User/Command/Handler/AddUserEmailHandler.php000066400000000000000000000024071335536502400237730ustar00rootroot00000000000000 */ 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.7.0/src/User/Command/Handler/AddUserRoleHandler.php000066400000000000000000000024201335536502400236400ustar00rootroot00000000000000 */ 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.7.0/src/User/Command/Handler/ChangeUserAttributeValueHandler.php000066400000000000000000000027251335536502400264040ustar00rootroot00000000000000 */ 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.7.0/src/User/Command/Handler/ChangeUserCredentialHandler.php000066400000000000000000000033761335536502400255210ustar00rootroot00000000000000 */ 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.7.0/src/User/Command/Handler/ConfirmUserEmailHandler.php000066400000000000000000000030371335536502400247000ustar00rootroot00000000000000 */ 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.7.0/src/User/Command/Handler/ConfirmUserHandler.php000066400000000000000000000027741335536502400237370ustar00rootroot00000000000000 */ 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.7.0/src/User/Command/Handler/CreateRoleHandler.php000066400000000000000000000020071335536502400235150ustar00rootroot00000000000000 */ final class CreateRoleHandler { use MessageDispatchingTrait; private $repository; public function __construct(EntityAwareFactoryInterface $factory, DomainMessageBusInterface $bus, RoleRepositoryInterface $repository) { $this->factory = $factory; $this->bus = $bus; $this->repository = $repository; } public function __invoke(CreateRoleCommand $command): void { $role = $this->factory->create(Role::class, $command->context); $this->repository->save($role); $this->dispatch(RoleCreatedEvent::class, [$role]); } } msgphp-0.7.0/src/User/Command/Handler/CreateUserHandler.php000066400000000000000000000021001335536502400235240ustar00rootroot00000000000000 */ 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.7.0/src/User/Command/Handler/DeleteRoleHandler.php000066400000000000000000000021661335536502400235220ustar00rootroot00000000000000 */ final class DeleteRoleHandler { use MessageDispatchingTrait; private $repository; public function __construct(EntityAwareFactoryInterface $factory, DomainMessageBusInterface $bus, RoleRepositoryInterface $repository) { $this->factory = $factory; $this->bus = $bus; $this->repository = $repository; } public function __invoke(DeleteRoleCommand $command): void { try { $role = $this->repository->find($command->roleName); } catch (EntityNotFoundException $e) { return; } $this->repository->delete($role); $this->dispatch(RoleDeletedEvent::class, [$role]); } } msgphp-0.7.0/src/User/Command/Handler/DeleteUserAttributeValueHandler.php000066400000000000000000000025231335536502400264150ustar00rootroot00000000000000 */ 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.7.0/src/User/Command/Handler/DeleteUserEmailHandler.php000066400000000000000000000022451335536502400245050ustar00rootroot00000000000000 */ 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.7.0/src/User/Command/Handler/DeleteUserHandler.php000066400000000000000000000022701335536502400235330ustar00rootroot00000000000000 */ 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.7.0/src/User/Command/Handler/DeleteUserRoleHandler.php000066400000000000000000000023641335536502400243610ustar00rootroot00000000000000 */ 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.7.0/src/User/Command/Handler/DisableUserHandler.php000066400000000000000000000027721335536502400237030ustar00rootroot00000000000000 */ 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.7.0/src/User/Command/Handler/EnableUserHandler.php000066400000000000000000000027601335536502400235230ustar00rootroot00000000000000 */ 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.7.0/src/User/Command/Handler/RequestUserPasswordHandler.php000066400000000000000000000031441335536502400255050ustar00rootroot00000000000000 */ 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.7.0/src/User/Command/RequestUserPasswordCommand.php000066400000000000000000000005361335536502400241330ustar00rootroot00000000000000 */ class RequestUserPasswordCommand { public $userId; public $token; final public function __construct($userId, string $token = null) { $this->userId = $userId; $this->token = $token; } } msgphp-0.7.0/src/User/CredentialInterface.php000066400000000000000000000003751335536502400211400ustar00rootroot00000000000000 */ interface CredentialInterface { public static function getUsernameField(): string; public function getUsername(): string; } msgphp-0.7.0/src/User/Entity/000077500000000000000000000000001335536502400160035ustar00rootroot00000000000000msgphp-0.7.0/src/User/Entity/Credential/000077500000000000000000000000001335536502400200555ustar00rootroot00000000000000msgphp-0.7.0/src/User/Entity/Credential/Anonymous.php000066400000000000000000000010061335536502400225530ustar00rootroot00000000000000 */ 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.7.0/src/User/Entity/Credential/Email.php000066400000000000000000000007661335536502400216260ustar00rootroot00000000000000 */ 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.7.0/src/User/Entity/Credential/EmailPassword.php000066400000000000000000000014771335536502400233510ustar00rootroot00000000000000 */ 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.7.0/src/User/Entity/Credential/EmailSaltedPassword.php000066400000000000000000000024151335536502400244770ustar00rootroot00000000000000 */ 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.7.0/src/User/Entity/Credential/Features/000077500000000000000000000000001335536502400216335ustar00rootroot00000000000000msgphp-0.7.0/src/User/Entity/Credential/Features/EmailAsUsername.php000066400000000000000000000010261335536502400253560ustar00rootroot00000000000000 */ 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.7.0/src/User/Entity/Credential/Features/NicknameAsUsername.php000066400000000000000000000010561335536502400260570ustar00rootroot00000000000000 */ 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.7.0/src/User/Entity/Credential/Features/PasswordProtected.php000066400000000000000000000010341335536502400260160ustar00rootroot00000000000000 */ 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.7.0/src/User/Entity/Credential/Features/PasswordWithSaltProtected.php000066400000000000000000000012251335536502400275000ustar00rootroot00000000000000 */ 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.7.0/src/User/Entity/Credential/Nickname.php000066400000000000000000000010211335536502400223050ustar00rootroot00000000000000 */ 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.7.0/src/User/Entity/Credential/NicknamePassword.php000066400000000000000000000015351335536502400240420ustar00rootroot00000000000000 */ 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.7.0/src/User/Entity/Credential/NicknameSaltedPassword.php000066400000000000000000000024611335536502400251760ustar00rootroot00000000000000 */ 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.7.0/src/User/Entity/Credential/Token.php000066400000000000000000000013141335536502400216450ustar00rootroot00000000000000 */ 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.7.0/src/User/Entity/Features/000077500000000000000000000000001335536502400175615ustar00rootroot00000000000000msgphp-0.7.0/src/User/Entity/Features/AbstractCredential.php000066400000000000000000000035261335536502400240360ustar00rootroot00000000000000 * * @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.7.0/src/User/Entity/Features/AbstractPasswordCredential.php000066400000000000000000000011141335536502400255500ustar00rootroot00000000000000 * * @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.7.0/src/User/Entity/Features/AbstractSaltedPasswordCredential.php000066400000000000000000000012021335536502400267030ustar00rootroot00000000000000 * * @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.7.0/src/User/Entity/Features/EmailCredential.php000066400000000000000000000011301335536502400233070ustar00rootroot00000000000000 */ 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.7.0/src/User/Entity/Features/EmailPasswordCredential.php000066400000000000000000000010251335536502400250350ustar00rootroot00000000000000 */ trait EmailPasswordCredential { use AbstractPasswordCredential; use EmailCredential { EmailCredential::handleChangeCredentialEvent insteadof AbstractPasswordCredential; } /** @var EmailPassword */ private $credential; public function getCredential(): EmailPassword { return $this->credential; } } msgphp-0.7.0/src/User/Entity/Features/EmailSaltedPasswordCredential.php000066400000000000000000000010711335536502400261730ustar00rootroot00000000000000 */ trait EmailSaltedPasswordCredential { use AbstractSaltedPasswordCredential; use EmailCredential { EmailCredential::handleChangeCredentialEvent insteadof AbstractSaltedPasswordCredential; } /** @var EmailSaltedPassword */ private $credential; public function getCredential(): EmailSaltedPassword { return $this->credential; } } msgphp-0.7.0/src/User/Entity/Features/NicknameCredential.php000066400000000000000000000011661335536502400240160ustar00rootroot00000000000000 */ 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.7.0/src/User/Entity/Features/NicknamePasswordCredential.php000066400000000000000000000010471335536502400255370ustar00rootroot00000000000000 */ trait NicknamePasswordCredential { use AbstractPasswordCredential; use NicknameCredential { NicknameCredential::handleChangeCredentialEvent insteadof AbstractPasswordCredential; } /** @var NicknamePassword */ private $credential; public function getCredential(): NicknamePassword { return $this->credential; } } msgphp-0.7.0/src/User/Entity/Features/NicknameSaltedPasswordCredential.php000066400000000000000000000011131335536502400266660ustar00rootroot00000000000000 */ trait NicknameSaltedPasswordCredential { use AbstractSaltedPasswordCredential; use NicknameCredential { NicknameCredential::handleChangeCredentialEvent insteadof AbstractSaltedPasswordCredential; } /** @var NicknameSaltedPassword */ private $credential; public function getCredential(): NicknameSaltedPassword { return $this->credential; } } msgphp-0.7.0/src/User/Entity/Features/ResettablePassword.php000066400000000000000000000023221335536502400241060ustar00rootroot00000000000000 */ 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.7.0/src/User/Entity/Features/TokenCredential.php000066400000000000000000000011301335536502400233400ustar00rootroot00000000000000 */ 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.7.0/src/User/Entity/Fields/000077500000000000000000000000001335536502400172115ustar00rootroot00000000000000msgphp-0.7.0/src/User/Entity/Fields/AttributeValuesField.php000066400000000000000000000014101335536502400240050ustar00rootroot00000000000000 */ trait AttributeValuesField { use AttributesField; /** @var iterable|UserAttributeValue[] */ private $attributeValues = []; /** * @return DomainCollectionInterface|UserAttributeValue[] */ public function getAttributeValues(): DomainCollectionInterface { return $this->attributeValues instanceof DomainCollectionInterface ? $this->attributeValues : DomainCollectionFactory::create($this->attributeValues); } } msgphp-0.7.0/src/User/Entity/Fields/EmailsField.php000066400000000000000000000011571335536502400221040ustar00rootroot00000000000000 */ trait EmailsField { /** @var iterable|UserEmail[] */ private $emails = []; /** * @return DomainCollectionInterface|UserEmail[] */ public function getEmails(): DomainCollectionInterface { return $this->emails instanceof DomainCollectionInterface ? $this->emails : DomainCollectionFactory::create($this->emails); } } msgphp-0.7.0/src/User/Entity/Fields/RoleField.php000066400000000000000000000006131335536502400215670ustar00rootroot00000000000000 */ trait RoleField { /** @var Role */ private $role; public function getRole(): Role { return $this->role; } public function getRoleName(): string { return $this->role->getName(); } } msgphp-0.7.0/src/User/Entity/Fields/RolesField.php000066400000000000000000000011461335536502400217540ustar00rootroot00000000000000 */ trait RolesField { /** @var iterable|UserRole[] */ private $roles = []; /** * @return DomainCollectionInterface|UserRole[] */ public function getRoles(): DomainCollectionInterface { return $this->roles instanceof DomainCollectionInterface ? $this->roles : DomainCollectionFactory::create($this->roles); } } msgphp-0.7.0/src/User/Entity/Fields/UserField.php000066400000000000000000000006611335536502400216070ustar00rootroot00000000000000 */ trait UserField { /** @var User */ private $user; public function getUser(): User { return $this->user; } public function getUserId(): UserIdInterface { return $this->user->getId(); } } msgphp-0.7.0/src/User/Entity/Role.php000066400000000000000000000003071335536502400174150ustar00rootroot00000000000000 */ abstract class Role { abstract public function getName(): string; } msgphp-0.7.0/src/User/Entity/User.php000066400000000000000000000006701335536502400174350ustar00rootroot00000000000000 */ abstract class User { abstract public function getId(): UserIdInterface; /** * @return CredentialInterface */ public function getCredential() { return new Anonymous(); } } msgphp-0.7.0/src/User/Entity/UserAttributeValue.php000066400000000000000000000010021335536502400223040ustar00rootroot00000000000000 */ abstract class UserAttributeValue { use UserField; use EntityAttributeValue; public function __construct(User $user, AttributeValue $attributeValue) { $this->user = $user; $this->attributeValue = $attributeValue; } } msgphp-0.7.0/src/User/Entity/UserEmail.php000066400000000000000000000007031335536502400204020ustar00rootroot00000000000000 */ 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.7.0/src/User/Entity/UserRole.php000066400000000000000000000005671335536502400202640ustar00rootroot00000000000000 */ abstract class UserRole { use UserField; use RoleField; public function __construct(User $user, Role $role) { $this->user = $user; $this->role = $role; } } msgphp-0.7.0/src/User/Entity/Username.php000066400000000000000000000007231335536502400202750ustar00rootroot00000000000000 */ abstract 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.7.0/src/User/Event/000077500000000000000000000000001335536502400156105ustar00rootroot00000000000000msgphp-0.7.0/src/User/Event/Domain/000077500000000000000000000000001335536502400170175ustar00rootroot00000000000000msgphp-0.7.0/src/User/Event/Domain/ChangeCredentialEvent.php000066400000000000000000000005531335536502400237150ustar00rootroot00000000000000 */ class ChangeCredentialEvent implements DomainEventInterface { public $fields; final public function __construct(array $fields) { $this->fields = $fields; } } msgphp-0.7.0/src/User/Event/Domain/RequestPasswordEvent.php000066400000000000000000000005561335536502400237130ustar00rootroot00000000000000 */ class RequestPasswordEvent implements DomainEventInterface { public $token; final public function __construct(string $token = null) { $this->token = $token; } } msgphp-0.7.0/src/User/Event/RoleCreatedEvent.php000066400000000000000000000004451335536502400215170ustar00rootroot00000000000000 */ class RoleCreatedEvent { public $role; final public function __construct(Role $role) { $this->role = $role; } } msgphp-0.7.0/src/User/Event/RoleDeletedEvent.php000066400000000000000000000004451335536502400215160ustar00rootroot00000000000000 */ class RoleDeletedEvent { public $role; final public function __construct(Role $role) { $this->role = $role; } } msgphp-0.7.0/src/User/Event/UserAttributeValueAddedEvent.php000066400000000000000000000006051335536502400240450ustar00rootroot00000000000000 */ class UserAttributeValueAddedEvent { public $userAttributeValue; final public function __construct(UserAttributeValue $userAttributeValue) { $this->userAttributeValue = $userAttributeValue; } } msgphp-0.7.0/src/User/Event/UserAttributeValueChangedEvent.php000066400000000000000000000010231335536502400243700ustar00rootroot00000000000000 */ 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.7.0/src/User/Event/UserAttributeValueDeletedEvent.php000066400000000000000000000006071335536502400244140ustar00rootroot00000000000000 */ class UserAttributeValueDeletedEvent { public $userAttributeValue; final public function __construct(UserAttributeValue $userAttributeValue) { $this->userAttributeValue = $userAttributeValue; } } msgphp-0.7.0/src/User/Event/UserConfirmedEvent.php000066400000000000000000000004471335536502400220750ustar00rootroot00000000000000 */ class UserConfirmedEvent { public $user; final public function __construct(User $user) { $this->user = $user; } } msgphp-0.7.0/src/User/Event/UserCreatedEvent.php000066400000000000000000000004451335536502400215340ustar00rootroot00000000000000 */ class UserCreatedEvent { public $user; final public function __construct(User $user) { $this->user = $user; } } msgphp-0.7.0/src/User/Event/UserCredentialChangedEvent.php000066400000000000000000000010601335536502400235030ustar00rootroot00000000000000 */ 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.7.0/src/User/Event/UserDeletedEvent.php000066400000000000000000000004451335536502400215330ustar00rootroot00000000000000 */ class UserDeletedEvent { public $user; final public function __construct(User $user) { $this->user = $user; } } msgphp-0.7.0/src/User/Event/UserDisabledEvent.php000066400000000000000000000004461335536502400216750ustar00rootroot00000000000000 */ class UserDisabledEvent { public $user; final public function __construct(User $user) { $this->user = $user; } } msgphp-0.7.0/src/User/Event/UserEmailAddedEvent.php000066400000000000000000000005061335536502400221340ustar00rootroot00000000000000 */ class UserEmailAddedEvent { public $userEmail; final public function __construct(UserEmail $userEmail) { $this->userEmail = $userEmail; } } msgphp-0.7.0/src/User/Event/UserEmailConfirmedEvent.php000066400000000000000000000005121335536502400230360ustar00rootroot00000000000000 */ class UserEmailConfirmedEvent { public $userEmail; final public function __construct(UserEmail $userEmail) { $this->userEmail = $userEmail; } } msgphp-0.7.0/src/User/Event/UserEmailDeletedEvent.php000066400000000000000000000005101335536502400224740ustar00rootroot00000000000000 */ class UserEmailDeletedEvent { public $userEmail; final public function __construct(UserEmail $userEmail) { $this->userEmail = $userEmail; } } msgphp-0.7.0/src/User/Event/UserEnabledEvent.php000066400000000000000000000004451335536502400215170ustar00rootroot00000000000000 */ class UserEnabledEvent { public $user; final public function __construct(User $user) { $this->user = $user; } } msgphp-0.7.0/src/User/Event/UserPasswordRequestedEvent.php000066400000000000000000000004571335536502400236540ustar00rootroot00000000000000 */ class UserPasswordRequestedEvent { public $user; final public function __construct(User $user) { $this->user = $user; } } msgphp-0.7.0/src/User/Event/UserRoleAddedEvent.php000066400000000000000000000004771335536502400220150ustar00rootroot00000000000000 */ class UserRoleAddedEvent { public $userRole; final public function __construct(UserRole $userRole) { $this->userRole = $userRole; } } msgphp-0.7.0/src/User/Event/UserRoleDeletedEvent.php000066400000000000000000000005011335536502400223460ustar00rootroot00000000000000 */ class UserRoleDeletedEvent { public $userRole; final public function __construct(UserRole $userRole) { $this->userRole = $userRole; } } msgphp-0.7.0/src/User/Infra/000077500000000000000000000000001335536502400155665ustar00rootroot00000000000000msgphp-0.7.0/src/User/Infra/Console/000077500000000000000000000000001335536502400171705ustar00rootroot00000000000000msgphp-0.7.0/src/User/Infra/Console/Command/000077500000000000000000000000001335536502400205465ustar00rootroot00000000000000msgphp-0.7.0/src/User/Infra/Console/Command/AddUserRoleCommand.php000066400000000000000000000043251335536502400247330ustar00rootroot00000000000000 */ 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.7.0/src/User/Infra/Console/Command/ChangeUserCredentialCommand.php000066400000000000000000000062731335536502400266050ustar00rootroot00000000000000 */ 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.7.0/src/User/Infra/Console/Command/ConfirmUserCommand.php000066400000000000000000000024021335536502400250100ustar00rootroot00000000000000 */ 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.7.0/src/User/Infra/Console/Command/CreateRoleCommand.php000066400000000000000000000037261335536502400246130ustar00rootroot00000000000000 */ final class CreateRoleCommand extends Command implements MessageReceivingInterface { use MessageDispatchingTrait; protected static $defaultName = 'role: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 RoleCreatedEvent) { $this->io->success('Created role '.$message->role->getName()); } } protected function configure(): void { $this->setDescription('Create a role'); $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(CreateRoleDomainCommand::class, [$context]); return 0; } } msgphp-0.7.0/src/User/Infra/Console/Command/CreateUserCommand.php000066400000000000000000000037531335536502400246300ustar00rootroot00000000000000 */ 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.7.0/src/User/Infra/Console/Command/DeleteRoleCommand.php000066400000000000000000000026661335536502400246140ustar00rootroot00000000000000 */ final class DeleteRoleCommand extends RoleCommand { protected static $defaultName = 'role:delete'; /** @var StyleInterface */ private $io; public function onMessageReceived($message): void { if ($message instanceof RoleDeletedEvent) { $this->io->success('Deleted role '.$message->role->getName()); } } protected function configure(): void { parent::configure(); $this->setDescription('Delete a role'); } protected function execute(InputInterface $input, OutputInterface $output): int { $this->io = new SymfonyStyle($input, $output); $role = $this->getRole($input, $this->io); if ($input->isInteractive()) { $this->io->note('Deleting role '.$role->getName()); if (!$this->io->confirm('Are you sure?')) { return 0; } } $this->dispatch(DeleteRoleDomainCommand::class, [$role->getName()]); return 0; } } msgphp-0.7.0/src/User/Infra/Console/Command/DeleteUserCommand.php000066400000000000000000000027361335536502400246270ustar00rootroot00000000000000 */ 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.7.0/src/User/Infra/Console/Command/DeleteUserRoleCommand.php000066400000000000000000000026561335536502400254520ustar00rootroot00000000000000 */ 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.7.0/src/User/Infra/Console/Command/DisableUserCommand.php000066400000000000000000000023771335536502400247710ustar00rootroot00000000000000 */ 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.7.0/src/User/Infra/Console/Command/EnableUserCommand.php000066400000000000000000000023661335536502400246120ustar00rootroot00000000000000 */ 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.7.0/src/User/Infra/Console/Command/RoleAwareTrait.php000066400000000000000000000015461335536502400241520ustar00rootroot00000000000000 */ trait RoleAwareTrait { /** @var RoleRepositoryInterface */ private $repository; 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.7.0/src/User/Infra/Console/Command/RoleCommand.php000066400000000000000000000022331335536502400234570ustar00rootroot00000000000000 */ abstract class RoleCommand extends Command implements MessageReceivingInterface { use RoleAwareTrait; use MessageDispatchingTrait { dispatch as protected; } private $repository; public function __construct(EntityAwareFactoryInterface $factory, DomainMessageBusInterface $bus, RoleRepositoryInterface $repository) { $this->factory = $factory; $this->bus = $bus; $this->repository = $repository; parent::__construct(); } /** * @internal */ public function onMessageReceived($message): void { } protected function configure(): void { $this->addArgument('role', InputArgument::OPTIONAL, 'The role name'); } } msgphp-0.7.0/src/User/Infra/Console/Command/SynchronizeUsernamesCommand.php000066400000000000000000000055111335536502400267560ustar00rootroot00000000000000 */ 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.7.0/src/User/Infra/Console/Command/UserCommand.php000066400000000000000000000040451335536502400234770ustar00rootroot00000000000000 */ 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.7.0/src/User/Infra/Console/Command/UserRoleCommand.php000066400000000000000000000016371335536502400243250ustar00rootroot00000000000000 */ abstract class UserRoleCommand extends UserCommand { use RoleAwareTrait; 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'); } } msgphp-0.7.0/src/User/Infra/Doctrine/000077500000000000000000000000001335536502400173355ustar00rootroot00000000000000msgphp-0.7.0/src/User/Infra/Doctrine/Event/000077500000000000000000000000001335536502400204165ustar00rootroot00000000000000msgphp-0.7.0/src/User/Infra/Doctrine/Event/UsernameListener.php000066400000000000000000000122751335536502400244230ustar00rootroot00000000000000 */ final class UsernameListener { private $factory; private $targetMappings; private $updateUsernames = []; public function __construct(EntityAwareFactoryInterface $factory, array $targetMappings) { $this->factory = $factory; $this->targetMappings = $targetMappings; } public function loadClassMetadata(LoadClassMetadataEventArgs $event): void { $metadata = $event->getClassMetadata(); if (!isset($this->targetMappings[$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->getTargetMapping($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($this->createUsername($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->getTargetMapping($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($this->createUsername($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->getTargetMapping($entity, $em) as $field => $mappedBy) { $user = null === $mappedBy ? $entity : $metadata->getFieldValue($entity, $mappedBy); if (null === $user || null === $username = $metadata->getFieldValue($entity, $field)) { continue; } yield $this->createUsername($user, $username); } } private function createUsername(User $user, string $username): Username { return $this->factory->create(Username::class, [$user, $username]); } private function getTargetMapping($entity, EntityManagerInterface $em): array { if (isset($this->targetMappings[$class = ClassUtils::getClass($entity)])) { return $this->targetMappings[$class]; } foreach ($em->getClassMetadata($class)->parentClasses as $parent) { if (isset($this->targetMappings[$parent])) { return $this->targetMappings[$parent]; } } throw new \LogicException(sprintf('No username mapping available for entity "%s".', $class)); } } msgphp-0.7.0/src/User/Infra/Doctrine/ObjectFieldMappings.php000066400000000000000000000061331335536502400237220ustar00rootroot00000000000000 * * @internal */ final class ObjectFieldMappings implements ObjectFieldMappingsProviderInterface { 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 provideObjectFieldMappings(): iterable { foreach (self::CREDENTIALS as $object => $credential) { yield $object => [ 'credential' => [ 'type' => self::TYPE_EMBEDDED, 'class' => $credential, 'columnPrefix' => null, ], ]; } yield Features\ResettablePassword::class => [ 'passwordResetToken' => [ 'type' => 'string', 'unique' => true, 'nullable' => true, ], 'passwordRequestedAt' => [ 'type' => 'datetime', 'nullable' => true, ], ]; yield Fields\AttributeValuesField::class => [ 'attributeValues' => [ 'type' => self::TYPE_ONE_TO_MANY, 'targetEntity' => UserAttributeValue::class, 'mappedBy' => 'user', ], ]; yield Fields\EmailsField::class => [ 'emails' => [ 'type' => self::TYPE_ONE_TO_MANY, 'targetEntity' => UserEmail::class, 'mappedBy' => 'user', 'indexBy' => 'email', ], ]; yield Fields\RoleField::class => [ 'role' => [ 'type' => self::TYPE_MANY_TO_ONE, 'targetEntity' => Role::class, 'joinColumns' => [ ['referencedColumnName' => 'name', 'nullable' => false], ], ], ]; yield Fields\RolesField::class => [ 'roles' => [ 'type' => self::TYPE_ONE_TO_MANY, 'targetEntity' => UserRole::class, 'mappedBy' => 'user', ], ]; yield Fields\UserField::class => [ 'user' => [ 'type' => self::TYPE_MANY_TO_ONE, 'targetEntity' => User::class, 'joinColumns' => [ ['nullable' => false], ], ], ]; } } msgphp-0.7.0/src/User/Infra/Doctrine/Repository/000077500000000000000000000000001335536502400215145ustar00rootroot00000000000000msgphp-0.7.0/src/User/Infra/Doctrine/Repository/RoleRepository.php000066400000000000000000000020351335536502400252260ustar00rootroot00000000000000 */ 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.7.0/src/User/Infra/Doctrine/Repository/UserAttributeValueRepository.php000066400000000000000000000054761335536502400301400ustar00rootroot00000000000000 */ 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.7.0/src/User/Infra/Doctrine/Repository/UserEmailRepository.php000066400000000000000000000023021335536502400262100ustar00rootroot00000000000000 */ 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.7.0/src/User/Infra/Doctrine/Repository/UserRepository.php000066400000000000000000000065071335536502400252530ustar00rootroot00000000000000 */ final class UserRepository implements UserRepositoryInterface { use DomainEntityRepositoryTrait { __construct as private __parent_construct; } private $alias = 'user'; private $usernameField; private $usernameClass; public function __construct(string $class, ?string $usernameField, ?string $usernameClass, EntityManagerInterface $em, DomainIdentityHelper $identityHelper = null) { $this->__parent_construct($class, $em, $identityHelper); $this->usernameField = $usernameField; $this->usernameClass = $usernameClass; } /** * @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 { $qb = $this->createQueryBuilderForUsername($username); if (null !== $qb) { try { return $qb->getQuery()->getSingleResult(); } catch (NoResultException $e) { throw EntityNotFoundException::createForFields($this->class, ['username' => $username]); } } return $this->doFindByFields($this->getUsernameCriteria($username)); } public function exists(UserIdInterface $id): bool { return $this->doExists($id); } public function usernameExists(string $username): bool { $qb = $this->createQueryBuilderForUsername($username); if (null !== $qb) { $qb->select('1'); return (bool) $qb->getQuery()->getScalarResult(); } return $this->doExistsByFields($this->getUsernameCriteria($username)); } public function save(User $user): void { $this->doSave($user); } public function delete(User $user): void { $this->doDelete($user); } private function getUsernameCriteria(string $username): array { if (null === $this->usernameField) { throw new \LogicException(sprintf('No username field available for entity "%s".', $this->class)); } return [$this->usernameField => $username]; } private function createQueryBuilderForUsername(string $username): ?QueryBuilder { if (null === $this->usernameClass) { return null; } $qb = $this->createQueryBuilder(); $qb->join($this->usernameClass, 'username', Join::WITH, 'username.user = '.$this->alias); $qb->where($qb->expr()->eq('username.username', ':username')); $qb->setMaxResults(1); $qb->setParameter('username', $username); return $qb; } } msgphp-0.7.0/src/User/Infra/Doctrine/Repository/UserRoleRepository.php000066400000000000000000000024611335536502400260700ustar00rootroot00000000000000 */ 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.7.0/src/User/Infra/Doctrine/Repository/UsernameRepository.php000066400000000000000000000100071335536502400261020ustar00rootroot00000000000000 */ final class UsernameRepository implements UsernameRepositoryInterface { use DomainEntityRepositoryTrait { __construct as private __parent_construct; } private $alias = 'username'; private $targetMappings; public function __construct(string $class, EntityManagerInterface $em, array $targetMappings = [], DomainIdentityHelper $identityHelper = null) { $this->__parent_construct($class, $em, $identityHelper); $this->targetMappings = $targetMappings; } /** * @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 { $results = $targets = []; foreach ($this->targetMappings as $class => $mapping) { $qb = $this->em->createQueryBuilder(); $metadata = $this->em->getClassMetadata($class); $fields = array_flip($idFields = $metadata->getIdentifierFieldNames()); foreach ($mapping 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.7.0/src/User/Infra/Doctrine/Resources/000077500000000000000000000000001335536502400213075ustar00rootroot00000000000000msgphp-0.7.0/src/User/Infra/Doctrine/Resources/dist-mapping/000077500000000000000000000000001335536502400237035ustar00rootroot00000000000000msgphp-0.7.0/src/User/Infra/Doctrine/Resources/dist-mapping/User.Entity.Credential.Email.orm.xml000066400000000000000000000007251335536502400325150ustar00rootroot00000000000000 User.Entity.Credential.EmailPassword.orm.xml000066400000000000000000000007771335536502400341700ustar00rootroot00000000000000msgphp-0.7.0/src/User/Infra/Doctrine/Resources/dist-mapping User.Entity.Credential.EmailSaltedPassword.orm.xml000066400000000000000000000010531335536502400353110ustar00rootroot00000000000000msgphp-0.7.0/src/User/Infra/Doctrine/Resources/dist-mapping msgphp-0.7.0/src/User/Infra/Doctrine/Resources/dist-mapping/User.Entity.Credential.Nickname.orm.xml000066400000000000000000000007331335536502400332120ustar00rootroot00000000000000 User.Entity.Credential.NicknamePassword.orm.xml000066400000000000000000000010051335536502400346470ustar00rootroot00000000000000msgphp-0.7.0/src/User/Infra/Doctrine/Resources/dist-mapping User.Entity.Credential.NicknameSaltedPassword.orm.xml000066400000000000000000000010611335536502400360060ustar00rootroot00000000000000msgphp-0.7.0/src/User/Infra/Doctrine/Resources/dist-mapping msgphp-0.7.0/src/User/Infra/Doctrine/Resources/dist-mapping/User.Entity.Credential.Token.orm.xml000066400000000000000000000007251335536502400325460ustar00rootroot00000000000000 msgphp-0.7.0/src/User/Infra/Doctrine/Resources/dist-mapping/User.Entity.Role.orm.xml000066400000000000000000000006231335536502400303130ustar00rootroot00000000000000 msgphp-0.7.0/src/User/Infra/Doctrine/Resources/dist-mapping/User.Entity.User.orm.xml000066400000000000000000000006231335536502400303300ustar00rootroot00000000000000 msgphp-0.7.0/src/User/Infra/Doctrine/Resources/dist-mapping/User.Entity.UserAttributeValue.orm.xml000066400000000000000000000015711335536502400332140ustar00rootroot00000000000000 msgphp-0.7.0/src/User/Infra/Doctrine/Resources/dist-mapping/User.Entity.UserEmail.orm.xml000066400000000000000000000011571335536502400313030ustar00rootroot00000000000000 msgphp-0.7.0/src/User/Infra/Doctrine/Resources/dist-mapping/User.Entity.UserRole.orm.xml000066400000000000000000000015461335536502400311570ustar00rootroot00000000000000 msgphp-0.7.0/src/User/Infra/Doctrine/Resources/dist-mapping/User.Entity.Username.orm.xml000066400000000000000000000011771335536502400311760ustar00rootroot00000000000000 msgphp-0.7.0/src/User/Infra/Doctrine/Type/000077500000000000000000000000001335536502400202565ustar00rootroot00000000000000msgphp-0.7.0/src/User/Infra/Doctrine/Type/UserIdType.php000066400000000000000000000004261335536502400230260ustar00rootroot00000000000000 */ final class UserIdType extends DomainIdType { public const NAME = 'msgphp_user_id'; } msgphp-0.7.0/src/User/Infra/Form/000077500000000000000000000000001335536502400164715ustar00rootroot00000000000000msgphp-0.7.0/src/User/Infra/Form/Type/000077500000000000000000000000001335536502400174125ustar00rootroot00000000000000msgphp-0.7.0/src/User/Infra/Form/Type/HashedPasswordType.php000066400000000000000000000147421335536502400237140ustar00rootroot00000000000000 */ 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('Current password confirmation requires "symfony/validator".'); } if (null === $this->tokenStorage) { throw new \LogicException('Current password confirmation requires "symfony/security".'); } $passwordOptions = self::withConstraint($passwordOptions, new Callback(function (?string $value, ExecutionContextInterface $context) use ($algorithm, $passwordOptions, &$plainPassword): void { $token = $this->tokenStorage->getToken(); if (null === $value || '' === $value || null === $token || !($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 confirmation 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.7.0/src/User/Infra/Security/000077500000000000000000000000001335536502400173755ustar00rootroot00000000000000msgphp-0.7.0/src/User/Infra/Security/DataCollector.php000066400000000000000000000056171335536502400226370ustar00rootroot00000000000000 * * @todo consider decorating instead * * @internal */ final class DataCollector extends BaseDataCollector { private $repository; public function __construct(TokenStorageInterface $tokenStorage = null, RoleHierarchyInterface $roleHierarchy = null, LogoutUrlGenerator $logoutUrlGenerator = null, AccessDecisionManagerInterface $accessDecisionManager = null, FirewallMapInterface $firewallMap = null, TraceableFirewallListener $firewall = null, UserRepositoryInterface $repository = null) { parent::__construct($tokenStorage, $roleHierarchy, $logoutUrlGenerator, $accessDecisionManager, $firewallMap, $firewall); $this->repository = $repository; } 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->getUserId()); } 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->getUserId()); break; } } } private function getUsername(UserIdInterface $id): string { if (null === $this->repository) { return $id->toString(); } try { return $this->repository->find($id)->getCredential()->getUsername(); } catch (EntityNotFoundException $e) { return $id->toString(); } } } msgphp-0.7.0/src/User/Infra/Security/Jwt/000077500000000000000000000000001335536502400201415ustar00rootroot00000000000000msgphp-0.7.0/src/User/Infra/Security/Jwt/SecurityUserProvider.php000066400000000000000000000034431335536502400250370ustar00rootroot00000000000000 */ final class SecurityUserProvider implements PayloadAwareUserProviderInterface { 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.7.0/src/User/Infra/Security/PasswordHashing.php000066400000000000000000000022401335536502400232100ustar00rootroot00000000000000 */ 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.7.0/src/User/Infra/Security/SecurityUser.php000066400000000000000000000051031335536502400225530ustar00rootroot00000000000000 */ final class SecurityUser implements UserInterface, EquatableInterface, \Serializable { private $id; private $originUsername; private $roles; private $password; private $passwordSalt; public function __construct(User $user, string $originUsername = null, array $roles = []) { $this->id = $user->getId(); if ($this->id->isEmpty()) { throw new \LogicException('The user ID cannot be empty.'); } $credential = $user->getCredential(); if (null === $originUsername && !$credential instanceof Anonymous) { $originUsername = $credential->getUsername(); } $this->originUsername = $originUsername; $this->roles = $roles; if ($credential instanceof PasswordProtectedInterface) { $this->password = $credential->getPassword(); $algorithm = $credential->getPasswordAlgorithm(); if (null !== $algorithm->salt) { $this->passwordSalt = $algorithm->salt->token; } } } public function getUserId(): UserIdInterface { return $this->id; } public function getOriginUsername(): ?string { return $this->originUsername; } public function getUsername(): string { return $this->id->toString(); } 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 && $user->getUserId()->equals($this->id); } public function serialize(): string { return serialize([$this->id, $this->originUsername, $this->roles, $this->password, $this->passwordSalt]); } public function unserialize($serialized): void { list($this->id, $this->originUsername, $this->roles, $this->password, $this->passwordSalt) = unserialize($serialized); } } msgphp-0.7.0/src/User/Infra/Security/SecurityUserProvider.php000066400000000000000000000041261335536502400242720ustar00rootroot00000000000000 */ final class SecurityUserProvider implements UserProviderInterface { private $repository; private $roleProvider; public function __construct(UserRepositoryInterface $repository, RoleProviderInterface $roleProvider = null) { $this->repository = $repository; $this->roleProvider = $roleProvider; } public function loadUserByUsername($username): UserInterface { try { $user = $this->repository->findByUsername($username); } catch (EntityNotFoundException $e) { throw new UsernameNotFoundException($e->getMessage()); } return $this->fromUser($user, $username); } public function refreshUser(UserInterface $user): UserInterface { if (!$user instanceof SecurityUser) { throw new UnsupportedUserException(sprintf('Unsupported user "%s".', \get_class($user))); } $securityUser = $user; try { $user = $this->repository->find($securityUser->getUserId()); } catch (EntityNotFoundException $e) { throw new UsernameNotFoundException($e->getMessage()); } return $this->fromUser($user, $securityUser->getOriginUsername()); } public function supportsClass($class): bool { return SecurityUser::class === $class; } public function fromUser(User $user, string $originUsername = null): SecurityUser { return new SecurityUser($user, $originUsername, $this->roleProvider ? $this->roleProvider->getRoles($user) : []); } } msgphp-0.7.0/src/User/Infra/Security/TokenStorageAwareTrait.php000066400000000000000000000021161335536502400244770ustar00rootroot00000000000000 * * @internal */ trait TokenStorageAwareTrait { private $tokenStorage; private $repository; public function __construct(TokenStorageInterface $tokenStorage, UserRepositoryInterface $repository) { $this->tokenStorage = $tokenStorage; $this->repository = $repository; } 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($user->getUserId()); } } msgphp-0.7.0/src/User/Infra/Security/UserArgumentValueResolver.php000066400000000000000000000014561335536502400252540ustar00rootroot00000000000000 */ 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.7.0/src/User/Infra/Security/UserParamConverter.php000066400000000000000000000017401335536502400236770ustar00rootroot00000000000000 */ 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.7.0/src/User/Infra/Uuid/000077500000000000000000000000001335536502400164745ustar00rootroot00000000000000msgphp-0.7.0/src/User/Infra/Uuid/UserId.php000066400000000000000000000004171335536502400204020ustar00rootroot00000000000000 */ final class UserId extends DomainId implements UserIdInterface { } msgphp-0.7.0/src/User/Infra/Validator/000077500000000000000000000000001335536502400175135ustar00rootroot00000000000000msgphp-0.7.0/src/User/Infra/Validator/ExistingUsername.php000066400000000000000000000010321335536502400235120ustar00rootroot00000000000000 */ final class ExistingUsername extends Constraint { public const DOES_NOT_EXIST_ERROR = '4a8b28f7-a2b5-4435-9dd8-3be5188d23f0'; protected static $errorNames = [ self::DOES_NOT_EXIST_ERROR => 'DOES_NOT_EXIST_ERROR', ]; public $message = 'This value is not valid.'; } msgphp-0.7.0/src/User/Infra/Validator/ExistingUsernameValidator.php000066400000000000000000000023171335536502400253670ustar00rootroot00000000000000 */ 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.7.0/src/User/Infra/Validator/UniqueUsername.php000066400000000000000000000010251335536502400231700ustar00rootroot00000000000000 */ final class UniqueUsername extends Constraint { public const IS_NOT_UNIQUE_ERROR = '37c4ba30-07ae-48e5-9767-19764e027346'; protected static $errorNames = [ self::IS_NOT_UNIQUE_ERROR => 'IS_NOT_UNIQUE_ERROR', ]; public $message = 'This value is not valid.'; } msgphp-0.7.0/src/User/Infra/Validator/UniqueUsernameValidator.php000066400000000000000000000023051335536502400250400ustar00rootroot00000000000000 */ 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.7.0/src/User/LICENSE000066400000000000000000000020601335536502400155320ustar00rootroot00000000000000MIT 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.7.0/src/User/Password/000077500000000000000000000000001335536502400163315ustar00rootroot00000000000000msgphp-0.7.0/src/User/Password/PasswordAlgorithm.php000066400000000000000000000032511335536502400225140ustar00rootroot00000000000000 */ 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.7.0/src/User/Password/PasswordHashing.php000066400000000000000000000051041335536502400221460ustar00rootroot00000000000000 */ 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) { $hash = password_hash($plainPassword, $algorithm->type, $algorithm->options); if (false === $hash) { throw new \RuntimeException(sprintf('Unable to hash password with algorithm "%s".', $algorithm->type)); } return $hash; } 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.7.0/src/User/Password/PasswordHashingInterface.php000066400000000000000000000005761335536502400237770ustar00rootroot00000000000000 */ interface PasswordHashingInterface { public function hash(string $plainPassword, PasswordAlgorithm $algorithm = null): string; public function isValid(string $hashedPassword, string $plainPassword, PasswordAlgorithm $algorithm = null): bool; } msgphp-0.7.0/src/User/Password/PasswordProtectedInterface.php000066400000000000000000000005751335536502400243460ustar00rootroot00000000000000 */ interface PasswordProtectedInterface { public function getPassword(): string; public function getPasswordAlgorithm(): PasswordAlgorithm; } msgphp-0.7.0/src/User/Password/PasswordSalt.php000066400000000000000000000006651335536502400214770ustar00rootroot00000000000000 */ 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.7.0/src/User/README.md000066400000000000000000000036721335536502400160160ustar00rootroot00000000000000# User Domain 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 - Symfony console commands - Symfony messenger commands & events - Symfony security infrastructure - Symfony validators - Doctrine persistence - 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.7.0/src/User/Repository/000077500000000000000000000000001335536502400167065ustar00rootroot00000000000000msgphp-0.7.0/src/User/Repository/RoleRepositoryInterface.php000066400000000000000000000011111335536502400242330ustar00rootroot00000000000000 */ 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.7.0/src/User/Repository/UserAttributeValueRepositoryInterface.php000066400000000000000000000030651335536502400271430ustar00rootroot00000000000000 */ 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.7.0/src/User/Repository/UserEmailRepositoryInterface.php000066400000000000000000000012651335536502400252320ustar00rootroot00000000000000 */ 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.7.0/src/User/Repository/UserRepositoryInterface.php000066400000000000000000000013621335536502400242600ustar00rootroot00000000000000 */ 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.7.0/src/User/Repository/UserRoleRepositoryInterface.php000066400000000000000000000013451335536502400251030ustar00rootroot00000000000000 */ 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.7.0/src/User/Repository/UsernameRepositoryInterface.php000066400000000000000000000014321335536502400251170ustar00rootroot00000000000000 */ 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.7.0/src/User/Role/000077500000000000000000000000001335536502400154305ustar00rootroot00000000000000msgphp-0.7.0/src/User/Role/ChainRoleProvider.php000066400000000000000000000013031335536502400215150ustar00rootroot00000000000000 */ final class ChainRoleProvider implements RoleProviderInterface { private $providers; /** * @param RoleProviderInterface[] $providers */ public function __construct(iterable $providers) { $this->providers = $providers; } public function getRoles(User $user): array { $roles = []; foreach ($this->providers as $provider) { foreach ($provider->getRoles($user) as $role) { $roles[$role] = true; } } return array_keys($roles); } } msgphp-0.7.0/src/User/Role/DefaultRoleProvider.php000066400000000000000000000010361335536502400220620ustar00rootroot00000000000000 */ final class DefaultRoleProvider implements RoleProviderInterface { private $roles; /** * @param string[] $roles */ public function __construct(array $roles, bool $sanitize = true) { $this->roles = $sanitize ? array_values(array_unique($roles)) : $roles; } public function getRoles(User $user): array { return $this->roles; } } msgphp-0.7.0/src/User/Role/RoleProviderInterface.php000066400000000000000000000004301335536502400223730ustar00rootroot00000000000000 */ interface RoleProviderInterface { /** * @return string[] */ public function getRoles(User $user): array; } msgphp-0.7.0/src/User/Role/UserRoleProvider.php000066400000000000000000000012761335536502400214220ustar00rootroot00000000000000 */ final class UserRoleProvider implements RoleProviderInterface { private $repository; public function __construct(UserRoleRepositoryInterface $repository) { $this->repository = $repository; } public function getRoles(User $user): array { $roles = $this->repository->findAllByUserId($user->getId())->map(function (UserRole $userRole) { return $userRole->getRoleName(); }); return array_values($roles); } } msgphp-0.7.0/src/User/UserId.php000066400000000000000000000003301335536502400164270ustar00rootroot00000000000000 */ final class UserId extends DomainId implements UserIdInterface { } msgphp-0.7.0/src/User/UserIdInterface.php000066400000000000000000000003261335536502400202550ustar00rootroot00000000000000 */ interface UserIdInterface extends DomainIdInterface { } msgphp-0.7.0/src/User/composer.json000066400000000000000000000024751335536502400172610ustar00rootroot00000000000000{ "name": "msgphp/user", "type": "library", "license": "MIT", "description": "A domain layer providing basic user management", "keywords": ["rich domain model", "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.7" }, "require-dev": { "doctrine/orm": "^2.6", "lexik/jwt-authentication-bundle": "^2.5", "msgphp/eav": "^0.7", "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.9|^4.0.9", "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": "0.7-dev" } } } msgphp-0.7.0/src/UserBundle/000077500000000000000000000000001335536502400156615ustar00rootroot00000000000000msgphp-0.7.0/src/UserBundle/.gitattributes000066400000000000000000000000641335536502400205540ustar00rootroot00000000000000Tests/ export-ignore phpunit.xml.dist export-ignore msgphp-0.7.0/src/UserBundle/.gitignore000066400000000000000000000000471335536502400176520ustar00rootroot00000000000000/composer.lock /composer.phar /vendor/ msgphp-0.7.0/src/UserBundle/DependencyInjection/000077500000000000000000000000001335536502400216025ustar00rootroot00000000000000msgphp-0.7.0/src/UserBundle/DependencyInjection/Compiler/000077500000000000000000000000001335536502400233545ustar00rootroot00000000000000msgphp-0.7.0/src/UserBundle/DependencyInjection/Compiler/CleanupPass.php000066400000000000000000000071051335536502400263060ustar00rootroot00000000000000 * * @internal */ final class CleanupPass implements CompilerPassInterface { public function process(ContainerBuilder $container): void { ContainerHelper::removeIf($container, !$container->has(Repository\RoleRepositoryInterface::class), [ Command\Handler\CreateRoleHandler::class, Command\Handler\DeleteRoleHandler::class, ConsoleInfra\Command\AddUserRoleCommand::class, ConsoleInfra\Command\CreateRoleCommand::class, ConsoleInfra\Command\DeleteRoleCommand::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, ConsoleInfra\Command\AddUserRoleCommand::class, ConsoleInfra\Command\DeleteUserRoleCommand::class, Role\UserRoleProvider::class, ]); } } msgphp-0.7.0/src/UserBundle/DependencyInjection/Configuration.php000066400000000000000000000275201335536502400251300ustar00rootroot00000000000000 * * @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, ]; public const DOCTRINE_TYPE_MAPPING = [ UserIdInterface::class => DoctrineInfra\Type\UserIdType::class, ]; public const DOCTRINE_REPOSITORY_MAPPING = [ Entity\Role::class => DoctrineInfra\Repository\RoleRepository::class, Entity\User::class => DoctrineInfra\Repository\UserRepository::class, Entity\Username::class => DoctrineInfra\Repository\UsernameRepository::class, Entity\UserAttributeValue::class => DoctrineInfra\Repository\UserAttributeValueRepository::class, Entity\UserRole::class => DoctrineInfra\Repository\UserRoleRepository::class, Entity\UserEmail::class => DoctrineInfra\Repository\UserEmailRepository::class, ]; public const CONSOLE_COMMAND_MAPPING = [ Command\AddUserRoleCommand::class => [ConsoleInfra\Command\AddUserRoleCommand::class], Command\ChangeUserCredentialCommand::class => [ConsoleInfra\Command\ChangeUserCredentialCommand::class], Command\ConfirmUserCommand::class => [ConsoleInfra\Command\ConfirmUserCommand::class], Command\CreateRoleCommand::class => [ConsoleInfra\Command\CreateRoleCommand::class], Command\CreateUserCommand::class => [ConsoleInfra\Command\CreateUserCommand::class], Command\DeleteRoleCommand::class => [ConsoleInfra\Command\DeleteRoleCommand::class], Command\DeleteUserCommand::class => [ConsoleInfra\Command\DeleteUserCommand::class], Command\DeleteUserRoleCommand::class => [ConsoleInfra\Command\DeleteUserRoleCommand::class], Command\DisableUserCommand::class => [ConsoleInfra\Command\DisableUserCommand::class], Command\EnableUserCommand::class => [ConsoleInfra\Command\EnableUserCommand::class], ]; private const COMMAND_MAPPING = [ Entity\Role::class => [ Command\CreateRoleCommand::class, Command\DeleteRoleCommand::class, ], Entity\User::class => [ Command\CreateUserCommand::class, Command\DeleteUserCommand::class, 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, Command\ChangeUserAttributeValueCommand::class, Command\DeleteUserAttributeValueCommand::class, ], Entity\UserEmail::class => [ Command\AddUserEmailCommand::class, Command\DeleteUserEmailCommand::class, Features\CanBeConfirmed::class => [ Command\ConfirmUserEmailCommand::class, ], ], Entity\UserRole::class => [ Command\AddUserRoleCommand::class, Command\DeleteUserRoleCommand::class, ], ]; private const DEFAULT_ROLE = 'ROLE_USER'; private static $packageDir; public static function getPackageDir(): string { return self::$packageDir ?? (self::$packageDir = \dirname((string) (new \ReflectionClass(UserIdInterface::class))->getFileName())); } 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]) ->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 !class_exists($value); }) ->thenInvalid('Target class %s does not exists.') ->end() ->end() ->scalarNode('field')->isRequired()->cannotBeEmpty()->end() ->scalarNode('mapped_by')->defaultNull()->end() ->end() ->end() ->validate() ->always(function (array $value): array { $result = []; foreach ($value as $lookup) { ['target' => $target, 'field' => $field, 'mapped_by' => $mappedBy] = $lookup; if (Entity\Username::class === $target || is_subclass_of($target, Entity\Username::class)) { throw new \LogicException(sprintf('Lookup target "%s" is not applicable.', (string) $target)); } if (null === $mappedBy && !is_subclass_of($target, Entity\User::class)) { throw new \LogicException(sprintf('Lookup for target "%s" must be a sub class of "%s" or specify the "mapped_by" node.', $target, Entity\User::class)); } $result[$target][$field] = $mappedBy; } return $result; }) ->end() ->end() ->arrayNode('role_providers') ->defaultValue(['default' => [self::DEFAULT_ROLE]]) ->requiresAtLeastOneElement() ->beforeNormalization() ->always(function ($value) { if (\is_array($value)) { if (!isset($value['default'])) { $value['default'] = [self::DEFAULT_ROLE]; } elseif (false === $value['default']) { $value['default'] = []; } elseif (!\is_array($value['default'])) { throw new \LogicException(sprintf('Default role provider must be of type array or false, got "%s".', \gettype($value['default']))); } } return $value; }) ->end() ->validate() ->always(function (array $value): array { foreach ($value as $k => $v) { if ('default' !== $k && !\is_string($v)) { throw new \LogicException(sprintf('Role provider must be of type string, got "%s".', \gettype($v))); } } return $value; }) ->end() ->variablePrototype()->end() ->end() ->arrayNode('doctrine') ->addDefaultsIfNotSet() ->children() ->booleanNode('auto_sync_username')->defaultTrue()->end() ->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']; $config['commands'][Command\ChangeUserCredentialCommand::class] = isset($config['username_field']) ? is_subclass_of($userClass, DomainEventHandlerInterface::class) : false; if ($config['username_lookup']) { if (!isset($config['class_mapping'][Entity\Username::class])) { throw new \LogicException(sprintf('Configuring "username_lookup" requires the "%s" entity to be mapped under "class_mapping".', Entity\Username::class)); } if (isset($config['username_field'])) { $config['username_lookup'][$userClass][$config['username_field']] = null; } } 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]; } $type = $reflection->getReturnType(); if (null === $type) { 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.7.0/src/UserBundle/DependencyInjection/Extension.php000066400000000000000000000231421335536502400242710ustar00rootroot00000000000000 * * @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); ExtensionHelper::configureDomain($container, $config['class_mapping'], Configuration::AGGREGATE_ROOTS, Configuration::IDENTITY_MAPPING); // default infra $loader->load('services.php'); // message infra $loader->load('message.php'); ExtensionHelper::finalizeCommandHandlers($container, $config['class_mapping'], $config['commands'], array_map(function (string $file): string { return 'MsgPhp\\User\\Event\\'.basename($file, '.php'); }, glob(Configuration::getPackageDir().'/Event/*Event.php'))); // persistence infra if (FeatureDetection::isDoctrineOrmAvailable($container)) { $this->loadDoctrineOrm($config, $loader, $container); } // framework infra if (FeatureDetection::isConsoleAvailable($container)) { $this->loadConsole($config, $loader, $container); } if (FeatureDetection::isFormAvailable($container)) { $loader->load('form.php'); } if (FeatureDetection::isValidatorAvailable($container)) { $loader->load('validator.php'); } if (FeatureDetection::hasSecurityBundle($container)) { $loader->load('security.php'); } if (FeatureDetection::hasTwigBundle($container)) { $loader->load('twig.php'); } $this->configureRoleProvider($config, $container); } public function prepend(ContainerBuilder $container): void { $config = $this->processConfiguration($this->getConfiguration($configs = $container->getExtensionConfig($this->getAlias()), $container), $configs); if (FeatureDetection::isDoctrineOrmAvailable($container)) { ExtensionHelper::configureDoctrineOrm( $container, $config['class_mapping'], $config['id_type_mapping'], Configuration::DOCTRINE_TYPE_MAPPING, self::getDoctrineMappingFiles($config, $container) ); } if (FeatureDetection::hasTwigBundle($container)) { $container->prependExtensionConfig('twig', [ 'globals' => [ Twig\GlobalVariable::NAME => '@'.Twig\GlobalVariable::class, ], ]); } } public function process(ContainerBuilder $container): void { if (FeatureDetection::hasSecurityBundle($container) && $container->hasDefinition($id = 'data_collector.security')) { $container->getDefinition($id) ->setClass(SecurityInfra\DataCollector::class) ->setArgument('$repository', new Reference(Repository\UserRepositoryInterface::class, ContainerBuilder::NULL_ON_INVALID_REFERENCE)); } } 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 (!FeatureDetection::hasMsgPhpEavBundle($container)) { unset($files[$baseDir.'/User.Entity.UserAttributeValue.orm.xml']); } return array_keys($files); } private function loadDoctrineOrm(array $config, LoaderInterface $loader, ContainerBuilder $container): void { $loader->load('doctrine.php'); $container->getDefinition(DoctrineInfra\Repository\UserRepository::class) ->setArgument('$usernameField', $config['username_field']) ->setArgument('$usernameClass', $config['username_lookup'] ? $config['class_mapping'][Entity\Username::class] : null); $container->getDefinition(DoctrineInfra\Repository\UsernameRepository::class) ->setArgument('$targetMappings', $config['username_lookup']) ->addTag('msgphp.domain.process_class_mapping', ['argument' => '$targetMappings', 'array_keys' => true]); if ($config['doctrine']['auto_sync_username']) { $container->getDefinition(DoctrineInfra\Event\UsernameListener::class) ->setArgument('$targetMappings', $config['username_lookup']) ->addTag('msgphp.domain.process_class_mapping', ['argument' => '$targetMappings', 'array_keys' => true]); } else { $container->removeDefinition(DoctrineInfra\Event\UsernameListener::class); } ExtensionHelper::finalizeDoctrineOrmRepositories($container, $config['class_mapping'], Configuration::DOCTRINE_REPOSITORY_MAPPING); } private function loadConsole(array $config, LoaderInterface $loader, ContainerBuilder $container): void { $loader->load('console.php'); $container->getDefinition(ConsoleInfra\Command\CreateUserCommand::class) ->setArgument('$contextFactory', ExtensionHelper::registerConsoleClassContextFactory( $container, $config['class_mapping'][Entity\User::class] )); if (isset($config['class_mapping'][Entity\Role::class])) { $container->getDefinition(ConsoleInfra\Command\CreateRoleCommand::class) ->setArgument('$contextFactory', ExtensionHelper::registerConsoleClassContextFactory( $container, $config['class_mapping'][Entity\Role::class] )); } if (isset($config['class_mapping'][Entity\UserRole::class])) { $container->getDefinition(ConsoleInfra\Command\AddUserRoleCommand::class) ->setArgument('$contextFactory', ExtensionHelper::registerConsoleClassContextFactory( $container, $config['class_mapping'][Entity\UserRole::class], ConsoleClassContextFactory::REUSE_DEFINITION )); } if (isset($config['username_field'])) { $container->getDefinition(ConsoleInfra\Command\ChangeUserCredentialCommand::class) ->setArgument('$contextFactory', ExtensionHelper::registerConsoleClassContextFactory( $container, $config['class_mapping'][CredentialInterface::class], ConsoleClassContextFactory::ALWAYS_OPTIONAL | ConsoleClassContextFactory::NO_DEFAULTS )); } ExtensionHelper::finalizeConsoleCommands($container, $config['commands'], Configuration::CONSOLE_COMMAND_MAPPING); } private function configureRoleProvider(array $config, ContainerBuilder $container): void { if (isset($config['class_mapping'][Entity\UserRole::class])) { $userProvider = $container->autowire(Role\UserRoleProvider::class); $userProvider->setPublic(false); } $providers = []; foreach ($config['role_providers'] as $factory => $provider) { if ('default' === $factory) { if (!$provider) { continue; } $defaultProvider = ContainerHelper::registerAnonymous($container, Role\DefaultRoleProvider::class, false, $defaultProviderId); $defaultProvider->setArgument('$roles', $provider); $provider = $defaultProviderId; } $providers[] = new Reference($provider); } $container->getDefinition(Role\ChainRoleProvider::class) ->setArgument('$providers', new IteratorArgument($providers)); } } msgphp-0.7.0/src/UserBundle/LICENSE000066400000000000000000000020601335536502400166640ustar00rootroot00000000000000MIT 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.7.0/src/UserBundle/Maker/000077500000000000000000000000001335536502400167205ustar00rootroot00000000000000msgphp-0.7.0/src/UserBundle/Maker/UserMaker.php000066400000000000000000000667401335536502400213440ustar00rootroot00000000000000 * * @internal */ final class UserMaker implements MakerInterface { private $classMapping; private $projectDir; private $credential; private $passwordReset = false; private $configs = []; private $services = []; private $routes = []; 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:msgphp'; } 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->routes = $this->writes = []; if (!isset($this->classMapping[Entity\User::class])) { throw new \LogicException('User class not configured. Did you install the bundle using Symfony Recipes?'); } if (!interface_exists(EntityManagerInterface::class)) { $io->note(['It\'s recommended to enable Doctrine ORM, run:', 'composer require orm']); if (!$io->confirm('Continue anyway?')) { return; } } if (!interface_exists(MessageBusInterface::class)) { $io->note(['It\'s recommended to enable Symfony Messenger, run:', 'composer require messenger']); if (!$io->confirm('Continue anyway?')) { return; } } if ($io->confirm('Enable Symfony Messenger configuration? (config/packages/messenger.yaml)')) { $this->writes[] = [$this->projectDir.'/config/packages/messenger.yaml', self::getSkeleton('messenger.php')]; } $this->user = new \ReflectionClass($this->classMapping[Entity\User::class]); $this->generateUser($io); $this->generateControllers($io); $this->generateConsole($io); if ($this->configs || $this->services) { array_unshift($this->writes, [$this->projectDir.'/config/packages/msgphp_user.make.php', self::getSkeleton('config.php', [ 'config' => $this->configs ? var_export(array_merge_recursive(...$this->configs), true) : null, 'services' => $this->services, ])]); $this->configs = $this->services = []; } if ($this->routes) { array_unshift($this->writes, [$this->projectDir.'/config/routes/user.php', self::getSkeleton('routes.php', [ 'routes' => $this->routes, ])]); $this->routes = []; } if (!$this->writes) { return; } $io->success('All questions have been answered!'); $io->note(\count($this->writes).' file(s) are about to be written'); $review = $io->confirm('Review changes? All changes will be written otherwise!'); $written = []; $writer = function (string $file, string $contents) use ($io, &$written): void { if (!file_put_contents($file, $contents)) { $io->error(sprintf('Cannot write changes to "%s"', $file)); return; } $written[] = $file; }; $differ = class_exists(Differ::class) ? new Differ() : null; $choices = ['y' => 'Yes', 'r' => 'No, show this review once more', 'n' => 'No, skip this file and continue']; while ($write = array_shift($this->writes)) { [$file, $contents] = $write; if (!is_dir($parent = \dirname($file))) { mkdir($parent, 0777, true); } if (!$review) { $writer($file, $contents); continue; } do { $io->text(''.(($exist = file_exists($file)) ? '[changed file]' : '[new file]').' '.$file); if (null === $differ) { if ($exist) { $io->writeln(['--- Original', file_get_contents($file), '+++ New', $contents]); } else { $io->writeln($contents); } } else { $io->writeln($differ->diff($exist ? file_get_contents($file) : '', $contents)); } } while ('r' === $choice = $io->choice('Write changes and continue reviewing?', $choices, $choices['r'])); if ('y' === $choice) { $writer($file, $contents); } } $io->success('Done!'); $io->note('Don\'t forget to update your database schema, if needed'); if ($io->confirm('Show written file names?')) { sort($written); $io->listing($written); } } 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->hasCredential() && $io->confirm('Generate a user credential?')) { $credentials = []; foreach (glob(Configuration::getPackageDir().'/Entity/Credential/*.php') as $file) { if ('Anonymous' === ($credential = basename($file, '.php')) || false !== strpos($credential, 'SaltedPassword')) { 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(); $this->passwordReset = true; } $roleProviders = []; if (!isset($this->classMapping[Entity\Role::class]) && $io->confirm('Can users have assigned 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', ]]; $roleProviders[] = Role\UserRoleProvider::class; } $defaultRoles = []; do { do { $defaultRole = $io->ask('Provide a default user role (e.g. ROLE_USER)'); } while (null === $defaultRole); $defaultRoles[] = $defaultRole; } while ($io->confirm('Add another default user role?', false)); $this->configs[] = ['role_providers' => ['default' => $defaultRoles] + $roleProviders]; // 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) || !class_exists(Route::class) || !interface_exists(FormInterface::class) || !interface_exists(ValidatorInterface::class) || !class_exists(Environment::class) || !interface_exists(MessageBusInterface::class) ) { $io->warning(['Not all controller dependencies are met, run:', 'composer require annotations router form validator twig messenger']); if (!$io->confirm('Continue anyway?')) { return; } } $usernameField = $this->hasCredential() ? $this->credential::getUsernameField() : null; $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 = $this->hasCredential() && $io->confirm('Add a registration controller?'); $hasForgotPassword = $this->passwordReset && $io->confirm('Add a forgot and reset password controller?'); $hasLogin = $this->hasPassword() && $io->confirm('Add a login and profile controller?'); // keep last if ($hasLogin) { if (!class_exists(Security::class)) { $io->warning(['Not all controller dependencies are met, run:', 'composer require security']); if (!$io->confirm('Continue anyway?')) { return; } } $this->routes[] = <<add('logout', '/logout') PHP; $this->writes[] = [$this->projectDir.'/config/packages/security.yaml', self::getSkeleton('security.php', [ 'hashAlgorithm' => $this->getPassordHashAlgorithm(), 'fieldName' => $usernameField, ])]; } if ($hasRegistration) { $this->writes[] = [$this->getClassFileName($nsForm.'\\RegisterType'), self::getSkeleton('form/RegisterType.php', [ 'hasPassword' => $this->hasPassword(), 'ns' => $nsForm, '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', [ 'hasPassword' => $this->hasPassword(), 'base' => $baseTemplate, 'block' => $baseTemplateBlock, 'fieldName' => $usernameField, ])]; } 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', [ 'hasForgotPassword' => $hasForgotPassword, 'base' => $baseTemplate, 'block' => $baseTemplateBlock, 'fieldName' => $usernameField, ])]; $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 { [$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(${contextElementFactoryClass}::class) ->alias(MsgPhp\\Domain\\Infra\\Console\\Context\\ClassContextElementFactoryInterface::class, ${contextElementFactoryClass}::class) 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 hasCredential(): bool { return $this->credential && Entity\Credential\Anonymous::class !== $this->credential; } private function hasPassword(): bool { return $this->hasCredential() && false !== strpos($this->credential, 'Password'); } private function getPassordHashAlgorithm(): string { if ($this->hasCredential() && false !== strpos($this->credential, 'SaltedPassword')) { return PasswordAlgorithm::DEFAULT_LEGACY; } switch (\PASSWORD_DEFAULT) { case \defined('PASSWORD_ARGON2I') ? \PASSWORD_ARGON2I : 2: return 'argon2i'; case \PASSWORD_BCRYPT: default: return 'bcrypt'; } } } msgphp-0.7.0/src/UserBundle/MsgPhpUserBundle.php000066400000000000000000000017611335536502400215660ustar00rootroot00000000000000 */ 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::build($container); } public function getContainerExtension(): ?ExtensionInterface { return new Extension(); } } msgphp-0.7.0/src/UserBundle/README.md000066400000000000000000000050231335536502400171400ustar00rootroot00000000000000# 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 - Symfony console commands - Symfony messenger commands & events - Symfony security infrastructure - Symfony validators - Doctrine persistence - Credential independent (supports e-mail, nickname, etc.) - Multiple username 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 messenger orm composer require maker --dev bin/console make:user:msgphp ``` And be done. ## 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.7.0/src/UserBundle/Resources/000077500000000000000000000000001335536502400176335ustar00rootroot00000000000000msgphp-0.7.0/src/UserBundle/Resources/config/000077500000000000000000000000001335536502400211005ustar00rootroot00000000000000msgphp-0.7.0/src/UserBundle/Resources/config/console.php000066400000000000000000000007641335536502400232620ustar00rootroot00000000000000services() ->defaults() ->autowire() ->autoconfigure() ->private() ->load('MsgPhp\\User\\Infra\\Console\\Command\\', Configuration::getPackageDir().'/Infra/Console/Command/*Command.php') ; }; msgphp-0.7.0/src/UserBundle/Resources/config/doctrine.php000066400000000000000000000022431335536502400234210ustar00rootroot00000000000000services() ->defaults() ->autowire() ->private() ->load('MsgPhp\\User\\Infra\\Doctrine\\Repository\\', Configuration::getPackageDir().'/Infra/Doctrine/Repository/*Repository.php') ->bind(EntityManagerInterface::class, ref('msgphp.doctrine.entity_manager')) ->set(Doctrine\ObjectFieldMappings::class) ->tag('msgphp.doctrine.object_field_mappings', ['priority' => -100]) ->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.7.0/src/UserBundle/Resources/config/form.php000066400000000000000000000006121335536502400225530ustar00rootroot00000000000000services() ->defaults() ->autowire() ->autoconfigure() ->private() ->set(Form\Type\HashedPasswordType::class) ; }; msgphp-0.7.0/src/UserBundle/Resources/config/message.php000066400000000000000000000007741335536502400232450ustar00rootroot00000000000000services() ->defaults() ->autowire() ->private() ->load('MsgPhp\\User\\Command\\Handler\\', Configuration::getPackageDir().'/Command/Handler/*Handler.php') ->tag('msgphp.domain.command_handler') ; }; msgphp-0.7.0/src/UserBundle/Resources/config/security.php000066400000000000000000000031601335536502400234600ustar00rootroot00000000000000services() ->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(PayloadAwareUserProviderInterface::class)) { $services->set(Security\Jwt\SecurityUserProvider::class); } }; msgphp-0.7.0/src/UserBundle/Resources/config/services.php000066400000000000000000000020341335536502400234330ustar00rootroot00000000000000services() ->defaults() ->autowire() ->autoconfigure() ->private() ->set(PasswordHashing::class) ->alias(PasswordHashingInterface::class, PasswordHashing::class) ->set(ChainRoleProvider::class) ->alias(RoleProviderInterface::class, ChainRoleProvider::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.7.0/src/UserBundle/Resources/config/twig.php000066400000000000000000000006011335536502400225600ustar00rootroot00000000000000services() ->defaults() ->autowire() ->autoconfigure() ->private() ->set(Twig\GlobalVariable::class) ; }; msgphp-0.7.0/src/UserBundle/Resources/config/validator.php000066400000000000000000000007161335536502400236020ustar00rootroot00000000000000services() ->defaults() ->autowire() ->autoconfigure() ->private() ->set(Validator\ExistingUsernameValidator::class) ->set(Validator\UniqueUsernameValidator::class) ; }; msgphp-0.7.0/src/UserBundle/Resources/skeleton/000077500000000000000000000000001335536502400214575ustar00rootroot00000000000000msgphp-0.7.0/src/UserBundle/Resources/skeleton/config.php000066400000000000000000000017731335536502400234450ustar00rootroot00000000000000extension('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->dispatch(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.7.0/src/UserBundle/Resources/skeleton/controller/LoginController.php000066400000000000000000000024051335536502400274700ustar00rootroot00000000000000createNamed('', 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.7.0/src/UserBundle/Resources/skeleton/controller/ProfileController.php000066400000000000000000000010201335536502400300100ustar00rootroot00000000000000render('${template}')); } } PHP; msgphp-0.7.0/src/UserBundle/Resources/skeleton/controller/RegisterController.php000066400000000000000000000030101335536502400301750ustar00rootroot00000000000000createNamed('', RegisterType::class); \$form->handleRequest(\$request); if (\$form->isSubmitted() && \$form->isValid()) { \$bus->dispatch(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.7.0/src/UserBundle/Resources/skeleton/controller/ResetPasswordController.php000066400000000000000000000040271335536502400312270ustar00rootroot00000000000000getRepository(${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->dispatch(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.7.0/src/UserBundle/Resources/skeleton/entity/000077500000000000000000000000001335536502400227735ustar00rootroot00000000000000msgphp-0.7.0/src/UserBundle/Resources/skeleton/entity/Role.php000066400000000000000000000007331335536502400244100ustar00rootroot00000000000000name = \$name; } public function getName(): string { return \$this->name; } } PHP; msgphp-0.7.0/src/UserBundle/Resources/skeleton/entity/UserRole.php000066400000000000000000000005571335536502400252530ustar00rootroot00000000000000add('${fieldName}', ${fieldType}::class, [ 'constraints' => [${constraints}], ]); } } PHP; msgphp-0.7.0/src/UserBundle/Resources/skeleton/form/LoginType.php000066400000000000000000000013571335536502400250530ustar00rootroot00000000000000add('${fieldName}', ${fieldType}::class); \$builder->add('password', PasswordType::class); } } PHP; msgphp-0.7.0/src/UserBundle/Resources/skeleton/form/RegisterType.php000066400000000000000000000027221335536502400255640ustar00rootroot00000000000000add('${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.7.0/src/UserBundle/Resources/skeleton/messenger.php000066400000000000000000000015571335536502400241700ustar00rootroot00000000000000label = 'E-mail'; break; PHP; } $constructor = '{'; if (false !== strpos($credentialClass, 'Password')) { $uses[] = 'use MsgPhp\User\Password\PasswordHashingInterface;'; $constructor = <<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; } $switch = ''; if ($cases) { $switch = "\n\n switch (\$argument) {\n".implode("\n", $cases)."\n }"; } sort($uses); $uses = implode("\n", $uses); return <<Forgot Password {{ form_start(form) }} {{ form_errors(form) }} {{ form_row(form.${fieldName}) }}
{{ form_end(form) }} {% endblock %} TWIG; msgphp-0.7.0/src/UserBundle/Resources/skeleton/template/login.html.php000066400000000000000000000011151335536502400260540ustar00rootroot00000000000000Forgot 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.7.0/src/UserBundle/Resources/skeleton/template/profile.html.php000066400000000000000000000005441335536502400264110ustar00rootroot00000000000000Your Profile

Logged in as: {{ ${userVariable}.current.${fieldName} }}

Logout

{% endblock %} TWIG; msgphp-0.7.0/src/UserBundle/Resources/skeleton/template/register.html.php000066400000000000000000000010261335536502400265710ustar00rootroot00000000000000Register {{ form_start(form) }} {{ form_errors(form) }} ${fields}
{{ form_end(form) }} {% endblock %} TWIG; msgphp-0.7.0/src/UserBundle/Resources/skeleton/template/reset_password.html.php000066400000000000000000000006451335536502400300170ustar00rootroot00000000000000Reset Password {{ form_start(form) }} {{ form_errors(form) }} {{ form_row(form.password.password) }} {{ form_row(form.password.confirmation) }}
{{ form_end(form) }} {% endblock %} TWIG; msgphp-0.7.0/src/UserBundle/Twig/000077500000000000000000000000001335536502400165735ustar00rootroot00000000000000msgphp-0.7.0/src/UserBundle/Twig/GlobalVariable.php000066400000000000000000000042341335536502400221550ustar00rootroot00000000000000 * * @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->getCurrentId()); } public function getCurrentId(): 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.'); } return $user->getUserId(); } public function isUserType(User $user, string $class): bool { return $user instanceof $class; } public static function getSubscribedServices(): array { return [ '?'.TokenStorageInterface::class, '?'.UserRepositoryInterface::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.7.0/src/UserBundle/composer.json000066400000000000000000000031421335536502400204030ustar00rootroot00000000000000{ "name": "msgphp/user-bundle", "type": "symfony-bundle", "license": "MIT", "description": "Basic user management (the `User` domain)", "keywords": ["rich domain model", "symfony", "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.7", "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", "msgphp/eav-bundle": "^0.7", "simple-bus/symfony-bridge": "^5.1", "symfony/console": "^3.4|^4.0", "symfony/form": "^3.4|^4.0", "symfony/maker-bundle": "^1.5", "symfony/messenger": "^4.1", "symfony/phpunit-bridge": "^3.4.9|^4.0.9", "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": "0.7-dev" } } } msgphp-0.7.0/tests/000077500000000000000000000000001335536502400141645ustar00rootroot00000000000000msgphp-0.7.0/tests/fixtures/000077500000000000000000000000001335536502400160355ustar00rootroot00000000000000msgphp-0.7.0/tests/fixtures/sa/000077500000000000000000000000001335536502400164405ustar00rootroot00000000000000msgphp-0.7.0/tests/fixtures/sa/return-static.php000066400000000000000000000006621335536502400217610ustar00rootroot00000000000000accept(SomeId::fromValue('id')); $test->accept($id = SomeId::fromValue('id')); // test it autocompletes //$id->auto