├── .editorconfig
├── .github
    ├── FUNDING.yml
    ├── ISSUE_TEMPLATE.md
    └── workflows
    │   ├── coding-standards.yml
    │   ├── issues.yml
    │   ├── pull-requests.yml
    │   ├── tests.yml
    │   └── update-changelog.yml
├── .gitignore
├── .vscode
    └── settings.json
├── CHANGELOG.md
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.md
├── LICENSE
├── composer.json
├── docker-compose.yml
├── php.dist.ini
├── phpunit.dist.xml
├── readme.md
├── src
    ├── Application
    │   ├── Application.php
    │   └── Exception
    │   │   ├── ApplicationAbortException.php
    │   │   ├── ApplicationException.php
    │   │   └── BaseErrorHandler.php
    ├── Auth
    │   ├── Auth.php
    │   ├── Authentication.php
    │   ├── AuthenticationConfiguration.php
    │   ├── Exception
    │   │   └── AuthenticationException.php
    │   ├── Guards
    │   │   ├── GuardContract.php
    │   │   ├── JwtGuard.php
    │   │   └── SessionGuard.php
    │   ├── README.md
    │   └── Traits
    │   │   └── LoginUserTrait.php
    ├── Cache
    │   ├── Adapters
    │   │   ├── CacheAdapterInterface.php
    │   │   ├── DatabaseAdapter.php
    │   │   ├── FilesystemAdapter.php
    │   │   └── RedisAdapter.php
    │   ├── Cache.php
    │   ├── CacheConfiguration.php
    │   └── README.md
    ├── Configuration
    │   ├── Configuration.php
    │   ├── EnvConfiguration.php
    │   ├── Loader.php
    │   ├── LoggerConfiguration.php
    │   └── README.md
    ├── Console
    │   ├── AbstractCommand.php
    │   ├── Argument.php
    │   ├── Color.php
    │   ├── Command.php
    │   ├── Command
    │   │   ├── ClearCommand.php
    │   │   ├── Generator
    │   │   │   ├── GenerateAppEventCommand.php
    │   │   │   ├── GenerateCacheCommand.php
    │   │   │   ├── GenerateConfigurationCommand.php
    │   │   │   ├── GenerateConsoleCommand.php
    │   │   │   ├── GenerateControllerCommand.php
    │   │   │   ├── GenerateEventListenerCommand.php
    │   │   │   ├── GenerateExceptionCommand.php
    │   │   │   ├── GenerateKeyCommand.php
    │   │   │   ├── GenerateMessagingCommand.php
    │   │   │   ├── GenerateMiddlewareCommand.php
    │   │   │   ├── GenerateMigrationCommand.php
    │   │   │   ├── GenerateModelCommand.php
    │   │   │   ├── GenerateNotificationCommand.php
    │   │   │   ├── GenerateProducerCommand.php
    │   │   │   ├── GenerateQueueCommand.php
    │   │   │   ├── GenerateRouterResourceCommand.php
    │   │   │   ├── GenerateSeederCommand.php
    │   │   │   ├── GenerateServiceCommand.php
    │   │   │   ├── GenerateSessionCommand.php
    │   │   │   └── GenerateValidationCommand.php
    │   │   ├── MigrationCommand.php
    │   │   ├── ReplCommand.php
    │   │   ├── SeederCommand.php
    │   │   ├── ServerCommand.php
    │   │   └── WorkerCommand.php
    │   ├── Console.php
    │   ├── Exception
    │   │   └── ConsoleException.php
    │   ├── Generator.php
    │   ├── README.md
    │   ├── Setting.php
    │   ├── Traits
    │   │   └── ConsoleTrait.php
    │   └── stubs
    │   │   ├── command.stub
    │   │   ├── configuration.stub
    │   │   ├── controller
    │   │       ├── controller.stub
    │   │       ├── no-plain.stub
    │   │       ├── rest.stub
    │   │       └── service.stub
    │   │   ├── event.stub
    │   │   ├── exception.stub
    │   │   ├── listener.stub
    │   │   ├── messaging.stub
    │   │   ├── middleware.stub
    │   │   ├── model
    │   │       ├── cache.stub
    │   │       ├── create.stub
    │   │       ├── model.stub
    │   │       ├── notification.stub
    │   │       ├── queue.stub
    │   │       ├── session.stub
    │   │       ├── standard.stub
    │   │       └── table.stub
    │   │   ├── producer.stub
    │   │   ├── seeder.stub
    │   │   ├── service.stub
    │   │   └── validation.stub
    ├── Container
    │   ├── Capsule.php
    │   ├── Compass.php
    │   ├── ContainerConfiguration.php
    │   ├── MiddlewareDispatcher.php
    │   └── README.md
    ├── Contracts
    │   ├── CollectionInterface.php
    │   └── ResponseInterface.php
    ├── Database
    │   ├── Barry
    │   │   ├── Builder.php
    │   │   ├── Concerns
    │   │   │   └── Relationship.php
    │   │   ├── Model.php
    │   │   ├── Relation.php
    │   │   ├── Relations
    │   │   │   ├── BelongsTo.php
    │   │   │   ├── BelongsToMany.php
    │   │   │   ├── HasMany.php
    │   │   │   └── HasOne.php
    │   │   └── Traits
    │   │   │   ├── ArrayAccessTrait.php
    │   │   │   ├── CanSerialized.php
    │   │   │   ├── EventTrait.php
    │   │   │   └── SerializableTrait.php
    │   ├── Collection.php
    │   ├── Connection
    │   │   ├── AbstractConnection.php
    │   │   ├── Adapters
    │   │   │   ├── MysqlAdapter.php
    │   │   │   ├── PostgreSQLAdapter.php
    │   │   │   └── SqliteAdapter.php
    │   │   └── Connection.php
    │   ├── Database.php
    │   ├── DatabaseConfiguration.php
    │   ├── Exception
    │   │   ├── ConnectionException.php
    │   │   ├── DatabaseException.php
    │   │   ├── MigrationException.php
    │   │   ├── ModelException.php
    │   │   ├── NotFoundException.php
    │   │   ├── QueryBuilderException.php
    │   │   └── SQLGeneratorException.php
    │   ├── Migration
    │   │   ├── Compose
    │   │   │   ├── MysqlCompose.php
    │   │   │   ├── PgsqlCompose.php
    │   │   │   └── SqliteCompose.php
    │   │   ├── Migration.php
    │   │   ├── Shortcut
    │   │   │   ├── ConstraintColumn.php
    │   │   │   ├── DateColumn.php
    │   │   │   ├── MixedColumn.php
    │   │   │   ├── NumberColumn.php
    │   │   │   └── TextColumn.php
    │   │   └── Table.php
    │   ├── Notification
    │   │   ├── DatabaseNotification.php
    │   │   └── WithNotification.php
    │   ├── Pagination.php
    │   ├── QueryBuilder.php
    │   ├── README.md
    │   └── Redis.php
    ├── Event
    │   ├── Contracts
    │   │   ├── AppEvent.php
    │   │   ├── EventListener.php
    │   │   └── EventShouldQueue.php
    │   ├── Dispatchable.php
    │   ├── Event.php
    │   ├── EventException.php
    │   ├── EventProducer.php
    │   ├── Listener.php
    │   └── README.md
    ├── Http
    │   ├── Client
    │   │   ├── HttpClient.php
    │   │   ├── HttpClientException.php
    │   │   └── Response.php
    │   ├── Exception
    │   │   ├── BadRequestException.php
    │   │   ├── CreatedException.php
    │   │   ├── ForbiddenException.php
    │   │   ├── HttpException.php
    │   │   ├── InternalServerErrorException.php
    │   │   ├── MethodNotAllowedException.php
    │   │   ├── NoContentException.php
    │   │   ├── NotFoundException.php
    │   │   ├── RequestException.php
    │   │   ├── ResponseException.php
    │   │   ├── ServerAccessControlException.php
    │   │   ├── UnauthorizedException.php
    │   │   └── UploadedFileException.php
    │   ├── HttpStatus.php
    │   ├── README.md
    │   ├── Redirect.php
    │   ├── Request.php
    │   ├── Response.php
    │   ├── ServerAccessControl.php
    │   └── UploadedFile.php
    ├── Mail
    │   ├── Adapters
    │   │   ├── LogAdapter.php
    │   │   ├── NativeAdapter.php
    │   │   ├── SesAdapter.php
    │   │   └── SmtpAdapter.php
    │   ├── Contracts
    │   │   └── MailAdapterInterface.php
    │   ├── Envelop.php
    │   ├── Exception
    │   │   ├── MailException.php
    │   │   ├── SmtpException.php
    │   │   └── SocketException.php
    │   ├── Mail.php
    │   ├── MailConfiguration.php
    │   ├── MailQueueProducer.php
    │   ├── README.md
    │   └── Security
    │   │   ├── DkimSigner.php
    │   │   └── SpfChecker.php
    ├── Messaging
    │   ├── Adapters
    │   │   ├── DatabaseChannelAdapter.php
    │   │   ├── MailChannelAdapter.php
    │   │   ├── SlackChannelAdapter.php
    │   │   ├── SmsChannelAdapter.php
    │   │   └── TelegramChannelAdapter.php
    │   ├── CanSendMessage.php
    │   ├── Contracts
    │   │   └── ChannelAdapterInterface.php
    │   ├── Messaging.php
    │   ├── MessagingQueueProducer.php
    │   └── README.md
    ├── Middleware
    │   ├── AuthMiddleware.php
    │   ├── BaseMiddleware.php
    │   └── CsrfMiddleware.php
    ├── Queue
    │   ├── Adapters
    │   │   ├── BeanstalkdAdapter.php
    │   │   ├── DatabaseAdapter.php
    │   │   ├── QueueAdapter.php
    │   │   ├── SQSAdapter.php
    │   │   └── SyncAdapter.php
    │   ├── Connection.php
    │   ├── ProducerService.php
    │   ├── QueueConfiguration.php
    │   ├── README.md
    │   └── WorkerService.php
    ├── Router
    │   ├── Exception
    │   │   └── RouterException.php
    │   ├── README.md
    │   ├── Resource.php
    │   ├── Route.php
    │   └── Router.php
    ├── Security
    │   ├── Crypto.php
    │   ├── CryptoConfiguration.php
    │   ├── Exception
    │   │   └── TokenMismatch.php
    │   ├── Hash.php
    │   ├── README.md
    │   ├── Sanitize.php
    │   └── Tokenize.php
    ├── Session
    │   ├── Adapters
    │   │   ├── ArrayAdapter.php
    │   │   ├── DatabaseAdapter.php
    │   │   ├── DurationTrait.php
    │   │   └── FilesystemAdapter.php
    │   ├── Cookie.php
    │   ├── Exception
    │   │   └── SessionException.php
    │   ├── README.md
    │   ├── Session.php
    │   └── SessionConfiguration.php
    ├── Storage
    │   ├── Contracts
    │   │   ├── FilesystemInterface.php
    │   │   └── ServiceInterface.php
    │   ├── Exception
    │   │   ├── DiskNotFoundException.php
    │   │   ├── ResourceException.php
    │   │   ├── ServiceConfigurationNotFoundException.php
    │   │   └── ServiceNotFoundException.php
    │   ├── README.md
    │   ├── Service
    │   │   ├── DiskFilesystemService.php
    │   │   ├── FTPService.php
    │   │   └── S3Service.php
    │   ├── Storage.php
    │   ├── StorageConfiguration.php
    │   └── Temporary.php
    ├── Support
    │   ├── Arraydotify.php
    │   ├── Collection.php
    │   ├── Env.php
    │   ├── Log.php
    │   ├── LoggerService.php
    │   ├── Serializes.php
    │   ├── Str.php
    │   ├── Util.php
    │   └── helpers.php
    ├── Testing
    │   ├── Assert.php
    │   ├── Features
    │   │   ├── FeatureHelper.php
    │   │   ├── Migration.php
    │   │   └── SeedingHelper.php
    │   ├── KernelTesting.php
    │   ├── README.md
    │   ├── Response.php
    │   └── TestCase.php
    ├── Translate
    │   ├── README.md
    │   ├── Translator.php
    │   └── TranslatorConfiguration.php
    ├── Validation
    │   ├── Exception
    │   │   ├── AuthorizationException.php
    │   │   └── ValidationException.php
    │   ├── FieldLexical.php
    │   ├── README.md
    │   ├── RequestValidation.php
    │   ├── Rules
    │   │   ├── DatabaseRule.php
    │   │   ├── DatetimeRule.php
    │   │   ├── EmailRule.php
    │   │   ├── NumericRule.php
    │   │   ├── RegexRule.php
    │   │   └── StringRule.php
    │   ├── Validate.php
    │   ├── Validator.php
    │   └── stubs
    │   │   └── lexical.php
    └── View
    │   ├── Engine
    │       ├── PHPEngine.php
    │       └── TwigEngine.php
    │   ├── EngineAbstract.php
    │   ├── Exception
    │       └── ViewException.php
    │   ├── README.md
    │   ├── View.php
    │   └── ViewConfiguration.php
└── tests
    ├── .gitkeep
    ├── Application
        └── ApplicationTest.php
    ├── Auth
        ├── AuthenticationTest.php
        └── Stubs
        │   └── UserModelStub.php
    ├── Cache
        ├── CacheDatabaseTest.php
        ├── CacheFilesystemTest.php
        └── CacheRedisTest.php
    ├── Config
        ├── ConfigurationTest.php
        ├── TestingConfiguration.php
        └── stubs
        │   ├── .key
        │   ├── app.php
        │   ├── auth.php
        │   ├── cache.php
        │   ├── database.php
        │   ├── mail.php
        │   ├── policier.php
        │   ├── queue.php
        │   ├── security.php
        │   ├── session.php
        │   ├── storage.php
        │   ├── stub.php
        │   ├── translate.php
        │   └── view.php
    ├── Console
        ├── ArgumentTest.php
        ├── CustomCommandTest.php
        ├── GeneratorBasicTest.php
        ├── GeneratorDeepTest.php
        ├── SettingTest.php
        ├── Stubs
        │   └── CustomCommand.php
        └── __snapshots__
        │   ├── GeneratorDeepTest__test_generate_cache_migration_stubs__1.txt
        │   ├── GeneratorDeepTest__test_generate_command_stubs__1.txt
        │   ├── GeneratorDeepTest__test_generate_configuration_stubs__1.txt
        │   ├── GeneratorDeepTest__test_generate_controller_no_plain_stubs__1.txt
        │   ├── GeneratorDeepTest__test_generate_controller_rest_stubs__1.txt
        │   ├── GeneratorDeepTest__test_generate_controller_stubs__1.txt
        │   ├── GeneratorDeepTest__test_generate_create_migration_stubs__1.txt
        │   ├── GeneratorDeepTest__test_generate_event_stubs__1.txt
        │   ├── GeneratorDeepTest__test_generate_exception_stubs__1.txt
        │   ├── GeneratorDeepTest__test_generate_listener_stubs__1.txt
        │   ├── GeneratorDeepTest__test_generate_messaging_stubs__1.txt
        │   ├── GeneratorDeepTest__test_generate_middleware_stubs__1.txt
        │   ├── GeneratorDeepTest__test_generate_model_cache_stubs__1.txt
        │   ├── GeneratorDeepTest__test_generate_model_create_stubs__1.txt
        │   ├── GeneratorDeepTest__test_generate_model_migration_stubs__1.txt
        │   ├── GeneratorDeepTest__test_generate_model_session_stubs__1.txt
        │   ├── GeneratorDeepTest__test_generate_model_standard_stubs__1.txt
        │   ├── GeneratorDeepTest__test_generate_model_stubs__1.txt
        │   ├── GeneratorDeepTest__test_generate_model_table_stubs__1.txt
        │   ├── GeneratorDeepTest__test_generate_producer_stubs__1.txt
        │   ├── GeneratorDeepTest__test_generate_queue_migration_stubs__1.txt
        │   ├── GeneratorDeepTest__test_generate_seeder_stubs__1.txt
        │   ├── GeneratorDeepTest__test_generate_seeder_stubs__2.txt
        │   ├── GeneratorDeepTest__test_generate_service_stubs__1.txt
        │   ├── GeneratorDeepTest__test_generate_session_migration_stubs__1.txt
        │   ├── GeneratorDeepTest__test_generate_standard_migration_stubs__1.txt
        │   ├── GeneratorDeepTest__test_generate_table_migration_stubs__1.txt
        │   └── GeneratorDeepTest__test_generate_validation_stubs__1.txt
    ├── Container
        ├── CapsuleTest.php
        └── Stubs
        │   └── MyClass.php
    ├── Database
        ├── ConnectionTest.php
        ├── Migration
        │   ├── MigrationTest.php
        │   ├── Mysql
        │   │   ├── SQLGeneratorTest.php
        │   │   └── SQLGenetorHelpersTest.php
        │   ├── Pgsql
        │   │   ├── SQLGeneratorTest.php
        │   │   └── SQLGenetorHelpersTest.php
        │   └── SQLite
        │   │   ├── SQLGeneratorTest.php
        │   │   └── SQLGenetorHelpersTest.php
        ├── PaginationTest.php
        ├── Query
        │   ├── DatabaseQueryTest.php
        │   ├── ModelQueryTest.php
        │   ├── PaginationTest.php
        │   └── QueryBuilderTest.php
        ├── RedisTest.php
        ├── Relation
        │   └── BelongsToRelationQueryTest.php
        └── Stubs
        │   ├── MigrationExtendedStub.php
        │   ├── PetMasterModelStub.php
        │   ├── PetModelStub.php
        │   └── PetWithMasterModelStub.php
    ├── Events
        ├── EventTest.php
        └── Stubs
        │   ├── EventModelStub.php
        │   ├── UserEventListenerStub.php
        │   └── UserEventStub.php
    ├── Filesystem
        ├── DiskFilesystemTest.php
        ├── FTPServiceTest.php
        ├── S3ServiceTest.php
        └── TemporaryTest.php
    ├── Hashing
        ├── SecurityTest.php
        └── stubs
        │   └── .key
    ├── Mail
        └── MailServiceTest.php
    ├── Messaging
        ├── MessagingTest.php
        └── Stubs
        │   ├── TestMessage.php
        │   └── TestNotifiableModel.php
    ├── Notification
        └── NotificationDatabaseTest.php
    ├── Queue
        ├── EventQueueTest.php
        ├── MailQueueTest.php
        ├── MessagingQueueTest.php
        ├── QueueTest.php
        └── Stubs
        │   ├── BasicProducerStubs.php
        │   ├── MixedProducerStub.php
        │   ├── ModelProducerStub.php
        │   ├── PetModelStub.php
        │   └── ServiceStub.php
    ├── Routing
        └── RouteTest.php
    ├── Support
        ├── ArraydotifyTest.php
        ├── CollectionTest.php
        ├── EnvTest.php
        ├── HttpClientTest.php
        ├── StrTest.php
        ├── TestingTest.php
        └── stubs
        │   └── env.json
    ├── Translate
        ├── TranslationTest.php
        └── stubs
        │   ├── en
        │       └── welcome.php
        │   └── fr
        │       └── welcome.php
    ├── Validation
        └── ValidationTest.php
    ├── View
        ├── ViewTest.php
        └── stubs
        │   ├── 404.twig
        │   ├── email.twig
        │   ├── mail.twig
        │   ├── php.php
        │   ├── tintin.tintin.php
        │   └── twig.twig
    └── bootstrap.php


/.editorconfig:
--------------------------------------------------------------------------------
1 | root = true
2 | 
3 | [*]
4 | charset = utf-8
5 | indent_style = space
6 | indent_size = 4
7 | end_of_line = lf
8 | insert_final_newline = true
9 | 


--------------------------------------------------------------------------------
/.github/FUNDING.yml:
--------------------------------------------------------------------------------
1 | # These are supported funding model platforms
2 | 
3 | github: [ papac ]
4 | open_collective: bowphp
5 | custom: [ "https://www.buymeacoffee.com/iOLqZ3h" ]
6 | 


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE.md:
--------------------------------------------------------------------------------
 1 | <!--
 2 | If you would like to propose new Bow features, please make a pull request, or open an issue at https://github.com/bowphp/tintin/issues.
 3 | -->
 4 | 
 5 | - Version: #.#.#
 6 | - Tintin Version: #.#.#
 7 | - PHP Version: #.#.#
 8 | - Database Adapters & Version: Mysql|Sqlite
 9 | 
10 | ### Description
11 | 
12 | ### Steps To Reproduce
13 | 


--------------------------------------------------------------------------------
/.github/workflows/coding-standards.yml:
--------------------------------------------------------------------------------
 1 | name: fix code styling
 2 | 
 3 | on:
 4 |   workflow_call:
 5 |     inputs:
 6 |       php:
 7 |         default: "8.1"
 8 |         type: string
 9 |       message:
10 |         default: Fix code styling
11 |         type: string
12 |       fix:
13 |         default: true
14 |         type: boolean
15 | 
16 | jobs:
17 |   lint:
18 |     runs-on: ubuntu-latest
19 | 
20 |     steps:
21 |       - name: Checkout code
22 |         uses: actions/checkout@v4
23 | 
24 |       - name: Setup PHP
25 |         uses: shivammathur/setup-php@v2
26 |         with:
27 |           php-version: ${{ inputs.php }}
28 |           extensions: json, dom, curl, libxml, mbstring
29 |           coverage: none
30 | 
31 |       - name: Install PHP CS
32 |         run: composer global require squizlabs/php_codesniffer
33 | 
34 |       - name: Run Phpcbf
35 |         run: phpcbf --standard=psr11 --tab-width=4 --severity=4
36 | 
37 |       - name: Commit linted files
38 |         if: ${{ inputs.fix }}
39 |         uses: stefanzweifel/git-auto-commit-action@v4
40 |         with:
41 |           commit_message: ${{ inputs.message }}
42 | 


--------------------------------------------------------------------------------
/.github/workflows/issues.yml:
--------------------------------------------------------------------------------
 1 | name: issues
 2 | 
 3 | on:
 4 |   issues:
 5 |     types: [labeled]
 6 | 
 7 | permissions:
 8 |   issues: write
 9 | 
10 | jobs:
11 |   help-wanted:
12 |     uses: bowphp/.github/.github/workflows/issues.yml@main
13 | 


--------------------------------------------------------------------------------
/.github/workflows/pull-requests.yml:
--------------------------------------------------------------------------------
 1 | name: pull requests
 2 | 
 3 | on:
 4 |   pull_request_target:
 5 |     types: [opened]
 6 | 
 7 | permissions:
 8 |   pull-requests: write
 9 | 
10 | jobs:
11 |   uneditable:
12 |     uses: bowphp/.github/.github/workflows/pull-requests.yml@main
13 | 


--------------------------------------------------------------------------------
/.github/workflows/update-changelog.yml:
--------------------------------------------------------------------------------
 1 | name: update changelog
 2 | 
 3 | on:
 4 |   release:
 5 |     types: [released]
 6 | 
 7 | jobs:
 8 |   update:
 9 |     uses: bowphp/.github/.github/workflows/update-changelog.yml@main
10 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | tests/data/database.sqlite
 2 | tests/data/cache/**
 3 | vendor
 4 | phpunit.xml
 5 | .idea
 6 | .DS_Store
 7 | .env.json
 8 | composer.lock
 9 | .phpunit.result.cache
10 | bob


--------------------------------------------------------------------------------
/.vscode/settings.json:
--------------------------------------------------------------------------------
1 | {
2 |   "yaml.schemas": {
3 |     "https://www.artillery.io/schema.json": []
4 |   }
5 | }
6 | 


--------------------------------------------------------------------------------
/CODE_OF_CONDUCT.md:
--------------------------------------------------------------------------------
1 | Bow's code of conduct is derived from the Ruby Code of Conduct. Any breach of the code of conduct may be reported to
2 | Franck DAKIA (dakiafranck@gmail.com).
3 | 
4 | - Participants will be tolerant of opposing points of view.
5 | - Participants must ensure that their language and actions are free from personal attacks and derogatory personal
6 |   remarks.
7 | - By interpreting the words and actions of others, participants must always assume good intentions.
8 | - Behavior that can reasonably be considered harassment will not be tolerated.
9 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2016 Franck DAKIA <dakiafranck@gmail.com>
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
16 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
17 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
18 | IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
19 | DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
20 | OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
21 | OR OTHER DEALINGS IN THE SOFTWARE.


--------------------------------------------------------------------------------
/php.dist.ini:
--------------------------------------------------------------------------------
1 | sendmail_path = /tmp/sendmail -t -i
2 | 


--------------------------------------------------------------------------------
/phpunit.dist.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <phpunit 
 3 |     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
 4 |     xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/9.5/phpunit.xsd" 
 5 |     colors="true" 
 6 |     bootstrap="tests/bootstrap.php" 
 7 |     verbose="true" 
 8 |     failOnRisky="true" 
 9 |     failOnWarning="true" 
10 |     convertErrorsToExceptions="true" 
11 |     convertNoticesToExceptions="true" 
12 |     convertWarningsToExceptions="true" 
13 |     stopOnFailure="false" 
14 |     executionOrder="random" 
15 |     resolveDependencies="true">
16 |     <testsuite name="Bow Framework">
17 |         <directory suffix=".php">tests/</directory>
18 |         <exclude>./tests/SessionTest.php</exclude>
19 |     </testsuite>
20 |     <php>
21 |         <env name="MYSQL_HOSTNAME" value="127.0.0.1"/>
22 |         <env name="MYSQL_DATABASE" value="test_db"/>
23 |         <env name="MYSQL_USER" value="root"/>
24 |         <env name="MYSQL_PASSWORD" value="password"/>
25 |         <env name="MYSQL_CHARSET" value="utf8"/>
26 |         <env name="MYSQL_COLLATE" value="utf8_unicode_ci"/>
27 |         <env name="FTP_HOST" value="127.0.0.1"/>
28 |         <env name="FTP_PASSWORD" value="password"/>
29 |         <env name="FTP_USERNAME" value="username"/>
30 |         <env name="FTP_PORT" value="21"/>
31 |         <env name="FTP_ROOT" value="."/>
32 |         <ini name="error_reporting" value="-1"/>
33 |         <ini name="display_errors" value="On"/>
34 |         <ini name="display_startup_errors" value="On"/>
35 |     </php>
36 |     <coverage>
37 |         <include>
38 |             <directory suffix=".php">src</directory>
39 |         </include>
40 |         <exclude>
41 |             <directory>vendor</directory>
42 |             <directory>tests</directory>
43 |         </exclude>
44 |     </coverage>
45 | </phpunit>
46 | 


--------------------------------------------------------------------------------
/src/Application/Exception/ApplicationAbortException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Application\Exception;
 6 | 
 7 | use ErrorException;
 8 | 
 9 | class ApplicationAbortException extends ErrorException
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Application/Exception/ApplicationException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Application\Exception;
 6 | 
 7 | use ErrorException;
 8 | 
 9 | class ApplicationException extends ErrorException
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Auth/Authentication.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Auth;
 6 | 
 7 | use Bow\Database\Barry\Model;
 8 | 
 9 | class Authentication extends Model
10 | {
11 |     /**
12 |      * Get the user id
13 |      *
14 |      * @return mixed
15 |      */
16 |     public function getAuthenticateUserId(): mixed
17 |     {
18 |         return $this->attributes[$this->primary_key];
19 |     }
20 | 
21 |     /**
22 |      * Define the additional values
23 |      *
24 |      * @return array
25 |      */
26 |     public function customJwtAttributes(): array
27 |     {
28 |         return [];
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Auth/AuthenticationConfiguration.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Auth;
 6 | 
 7 | use Bow\Configuration\Configuration;
 8 | use Bow\Configuration\Loader;
 9 | 
10 | class AuthenticationConfiguration extends Configuration
11 | {
12 |     /**
13 |      * @inheritdoc
14 |      */
15 |     public function create(Loader $config): void
16 |     {
17 |         $this->container->bind(
18 |             'auth',
19 |             function () use ($config) {
20 |                 return Auth::configure($config['auth']);
21 |             }
22 |         );
23 |     }
24 | 
25 |     /**
26 |      * @inheritdoc
27 |      */
28 |     public function run(): void
29 |     {
30 |         $this->container->make('auth');
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Auth/Exception/AuthenticationException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Auth\Exception;
 6 | 
 7 | use Exception;
 8 | 
 9 | class AuthenticationException extends Exception
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Auth/README.md:
--------------------------------------------------------------------------------
 1 | # Bow Auth
 2 | 
 3 | Bow Framework auth is a native authentification system
 4 | 
 5 | ```php
 6 | use Bow\Http\Exception\UnauthorizedException;
 7 | 
 8 | $auth = app_auth();
 9 | 
10 | $logged = $auth->attempts(["username" => "name@example.com", "password" => "password"]);
11 | 
12 | if (!$logged) {
13 |     throw new UnauthorizedException("Access denied");
14 | }
15 | 
16 | $user = $auth->user();
17 | ```
18 | 
19 | Enjoy!
20 | 


--------------------------------------------------------------------------------
/src/Auth/Traits/LoginUserTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Auth\Traits;
 6 | 
 7 | use Bow\Auth\Authentication;
 8 | use Bow\Auth\Exception\AuthenticationException;
 9 | use Bow\Database\Barry\Model;
10 | 
11 | trait LoginUserTrait
12 | {
13 |     /**
14 |      * Make login
15 |      *
16 |      * @param  array $credentials
17 |      * @return ?Authentication
18 |      * @throws AuthenticationException
19 |      */
20 |     private function makeLogin(array $credentials): ?Authentication
21 |     {
22 |         $model = $this->provider['model'];
23 |         $fields = $this->provider['credentials'];
24 | 
25 |         if (!isset($credentials[$fields['username']])) {
26 |             throw new AuthenticationException(
27 |                 "Please check your passed variable for make attemps login."
28 |                 . "The 'credentials.{$fields['username']}' key not found."
29 |             );
30 |         }
31 | 
32 |         if (!isset($credentials[$fields['password']])) {
33 |             throw new AuthenticationException(
34 |                 "Please check your passed variable for make attemps login."
35 |                 . "The 'credentials.{$fields['password']}' key not found."
36 |             );
37 |         }
38 | 
39 |         $column = $fields['username'];
40 |         $value = $credentials[$fields['username']];
41 | 
42 |         return $model::where($column, $value)->first();
43 |     }
44 | 
45 |     /**
46 |      * Get user by key
47 |      *
48 |      * @param  string           $key
49 |      * @param  float|int|string $value
50 |      * @return Model|null
51 |      */
52 |     private function getUserBy(string $key, float|int|string $value): ?Authentication
53 |     {
54 |         $model = $this->provider['model'];
55 | 
56 |         return $model::where($key, $value)->first();
57 |     }
58 | }
59 | 


--------------------------------------------------------------------------------
/src/Cache/CacheConfiguration.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Cache;
 6 | 
 7 | use Bow\Configuration\Configuration;
 8 | use Bow\Configuration\Loader;
 9 | 
10 | class CacheConfiguration extends Configuration
11 | {
12 |     /**
13 |      * @inheritdoc
14 |      */
15 |     public function create(Loader $config): void
16 |     {
17 |         $this->container->bind(
18 |             'cache',
19 |             function () use ($config) {
20 |                 return Cache::configure($config['cache']);
21 |             }
22 |         );
23 |     }
24 | 
25 |     /**
26 |      * @inheritdoc
27 |      */
28 |     public function run(): void
29 |     {
30 |         $this->container->make('cache');
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Cache/README.md:
--------------------------------------------------------------------------------
 1 | # Bow Cache
 2 | 
 3 | Bow Framework's cache system is very simple cache manager
 4 | 
 5 | - Filesystem
 6 | - Database
 7 | - Redis
 8 | - With extended driver interface
 9 | 
10 | Let's show a little exemple:
11 | 
12 | ```php
13 | $content = cache("name");
14 | ```
15 | 
16 | By specifying the driver:
17 | 
18 | ```
19 | $content = Cache::store('redis')->get('name');
20 | ```
21 | 
22 | Is very enjoyful api
23 | 


--------------------------------------------------------------------------------
/src/Configuration/Configuration.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Configuration;
 6 | 
 7 | use Bow\Container\Capsule as Container;
 8 | 
 9 | abstract class Configuration
10 | {
11 |     /**
12 |      * @var Container
13 |      */
14 |     protected Container $container;
15 | 
16 |     /**
17 |      * Service constructor.
18 |      *
19 |      * @param Container $container
20 |      */
21 |     public function __construct(Container $container)
22 |     {
23 |         $this->container = $container;
24 |     }
25 | 
26 |     /**
27 |      * Get the container instance
28 |      *
29 |      * @return Container
30 |      */
31 |     public function getContainer(): Container
32 |     {
33 |         return $this->container;
34 |     }
35 | 
36 |     /**
37 |      * Get la service class name
38 |      *
39 |      * @return string
40 |      */
41 |     public function getName(): string
42 |     {
43 |         return get_called_class();
44 |     }
45 | 
46 |     /**
47 |      * Create and configure the server or package
48 |      *
49 |      * @param  Loader $config
50 |      * @return void
51 |      */
52 |     abstract public function create(Loader $config): void;
53 | 
54 |     /**
55 |      * Start the configured package
56 |      *
57 |      * @return void
58 |      */
59 |     abstract public function run(): void;
60 | }
61 | 


--------------------------------------------------------------------------------
/src/Configuration/EnvConfiguration.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Configuration;
 6 | 
 7 | use Bow\Support\Env;
 8 | use InvalidArgumentException;
 9 | 
10 | class EnvConfiguration extends Configuration
11 | {
12 |     /**
13 |      * @inheritdoc
14 |      */
15 |     public function create(Loader $config): void
16 |     {
17 |         $this->container->bind(
18 |             'env',
19 |             function () use ($config) {
20 |                 $path = $config['app.env_file'];
21 |                 if ($path === false) {
22 |                     throw new InvalidArgumentException(
23 |                         "The application environment file [.env.json] is not exists. "
24 |                         . "Copy the .env.example.json file to .env.json"
25 |                     );
26 |                 }
27 | 
28 |                 Env::load($config['app.env_file']);
29 |             }
30 |         );
31 |     }
32 | 
33 |     /**
34 |      * @inheritdoc
35 |      */
36 |     public function run(): void
37 |     {
38 |         $this->container->make('env');
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Configuration/README.md:
--------------------------------------------------------------------------------
1 | # Bow Configuration
2 | 
3 | Bow Framework's configuration system is very simple
4 | 


--------------------------------------------------------------------------------
/src/Console/AbstractCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Console;
 6 | 
 7 | use Bow\Console\Traits\ConsoleTrait;
 8 | 
 9 | abstract class AbstractCommand
10 | {
11 |     use ConsoleTrait;
12 | 
13 |     /**
14 |      * Store dirname
15 |      *
16 |      * @var Setting
17 |      */
18 |     protected Setting $setting;
19 | 
20 |     /**
21 |      * The application namespace
22 |      *
23 |      * @var array
24 |      */
25 |     protected array $namespaces;
26 | 
27 |     /**
28 |      * The Arg Option instance
29 |      *
30 |      * @var Argument
31 |      */
32 |     protected Argument $arg;
33 | 
34 |     /**
35 |      * AbstractCommand constructor
36 |      *
37 |      * @param  Setting  $setting
38 |      * @param  Argument $arg
39 |      * @return void
40 |      */
41 |     public function __construct(Setting $setting, Argument $arg)
42 |     {
43 |         $this->setting = $setting;
44 |         $this->arg = $arg;
45 |         $this->namespaces = $setting->getNamespaces();
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/src/Console/Command/Generator/GenerateAppEventCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Console\Command\Generator;
 6 | 
 7 | use Bow\Console\AbstractCommand;
 8 | use Bow\Console\Generator;
 9 | 
10 | class GenerateAppEventCommand extends AbstractCommand
11 | {
12 |     /**
13 |      * Add event
14 |      *
15 |      * @param  string $event
16 |      * @return void
17 |      */
18 |     public function run(string $event): void
19 |     {
20 |         $generator = new Generator(
21 |             $this->setting->getEventDirectory(),
22 |             $event
23 |         );
24 | 
25 |         if ($generator->fileExists()) {
26 |             echo "\033[0;31mThe event already exists.\033[00m\n";
27 | 
28 |             exit(1);
29 |         }
30 | 
31 |         $generator->write('event', [
32 |             'baseNamespace' => $this->namespaces['event'] ?? 'App\\Events'
33 |         ]);
34 | 
35 |         echo "\033[0;32mThe event has been well created.\033[00m\n";
36 | 
37 |         exit(0);
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Console/Command/Generator/GenerateCacheCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Console\Command\Generator;
 6 | 
 7 | use Bow\Console\AbstractCommand;
 8 | use Bow\Console\Color;
 9 | use Bow\Console\Generator;
10 | use Bow\Support\Str;
11 | 
12 | class GenerateCacheCommand extends AbstractCommand
13 | {
14 |     /**
15 |      * Generate session
16 |      *
17 |      * @return void
18 |      */
19 |     public function run(): void
20 |     {
21 |         $create_at = date("YmdHis");
22 |         $filename = sprintf("Version%s%sTable", $create_at, ucfirst(Str::camel('caches')));
23 | 
24 |         $generator = new Generator(
25 |             $this->setting->getMigrationDirectory(),
26 |             $filename
27 |         );
28 | 
29 |         $generator->write('model/cache', [
30 |             'className' => $filename
31 |         ]);
32 | 
33 |         echo Color::green('Cache migration created.');
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/Console/Command/Generator/GenerateConfigurationCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Console\Command\Generator;
 6 | 
 7 | use Bow\Console\AbstractCommand;
 8 | use Bow\Console\Color;
 9 | use Bow\Console\Generator;
10 | 
11 | class GenerateConfigurationCommand extends AbstractCommand
12 | {
13 |     /**
14 |      * Add configuration
15 |      *
16 |      * @param  string $configuration
17 |      * @return void
18 |      */
19 |     public function run(string $configuration): void
20 |     {
21 |         $generator = new Generator(
22 |             $this->setting->getPackageDirectory(),
23 |             $configuration
24 |         );
25 | 
26 |         if ($generator->fileExists()) {
27 |             echo Color::red('The configuration already exists.');
28 | 
29 |             exit(0);
30 |         }
31 | 
32 |         $generator->write('configuration', [
33 |             'baseNamespace' => $this->namespaces['configuration']
34 |         ]);
35 | 
36 |         echo Color::green('The configuration was well created.');
37 | 
38 |         exit(0);
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Console/Command/Generator/GenerateConsoleCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Console\Command\Generator;
 6 | 
 7 | use Bow\Console\AbstractCommand;
 8 | use Bow\Console\Generator;
 9 | 
10 | class GenerateConsoleCommand extends AbstractCommand
11 | {
12 |     /**
13 |      * Add service
14 |      *
15 |      * @param  string $service
16 |      * @return void
17 |      */
18 |     public function run(string $service): void
19 |     {
20 |         $generator = new Generator(
21 |             $this->setting->getCommandDirectory(),
22 |             $service
23 |         );
24 | 
25 |         if ($generator->fileExists()) {
26 |             echo "\033[0;31mThe command already exists.\033[00m\n";
27 | 
28 |             exit(1);
29 |         }
30 | 
31 |         $generator->write('command', [
32 |             'baseNamespace' => $this->namespaces['command'] ?? 'App\\Commands'
33 |         ]);
34 | 
35 |         echo "\033[0;32mThe command has been well created.\033[00m\n";
36 | 
37 |         exit(0);
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Console/Command/Generator/GenerateControllerCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Console\Command\Generator;
 6 | 
 7 | use Bow\Console\AbstractCommand;
 8 | use Bow\Console\Generator;
 9 | 
10 | class GenerateControllerCommand extends AbstractCommand
11 | {
12 |     /**
13 |      * The add controller command
14 |      *
15 |      * @param  string $controller
16 |      * @return void
17 |      */
18 |     public function run(string $controller): void
19 |     {
20 |         $generator = new Generator(
21 |             $this->setting->getControllerDirectory(),
22 |             $controller
23 |         );
24 | 
25 |         if ($generator->fileExists()) {
26 |             echo "\033[0;31mThe controller already exists.\033[00m\n";
27 | 
28 |             exit(1);
29 |         }
30 | 
31 |         if ($this->arg->getParameter('--no-plain')) {
32 |             $generator->write('controller/no-plain', [
33 |                 'baseNamespace' => $this->namespaces['controller']
34 |             ]);
35 |         } else {
36 |             $generator->write('controller/controller', [
37 |                 'baseNamespace' => $this->namespaces['controller']
38 |             ]);
39 |         }
40 | 
41 |         echo "\033[0;32mThe controller was well created.\033[00m\n";
42 | 
43 |         exit(0);
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/Console/Command/Generator/GenerateEventListenerCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Console\Command\Generator;
 6 | 
 7 | use Bow\Console\AbstractCommand;
 8 | use Bow\Console\Generator;
 9 | 
10 | class GenerateEventListenerCommand extends AbstractCommand
11 | {
12 |     /**
13 |      * Add event
14 |      *
15 |      * @param  string $event
16 |      * @return void
17 |      */
18 |     public function run(string $event): void
19 |     {
20 |         $generator = new Generator(
21 |             $this->setting->getEventListenerDirectory(),
22 |             $event
23 |         );
24 | 
25 |         if ($generator->fileExists()) {
26 |             echo "\033[0;31mThe event already exists.\033[00m\n";
27 | 
28 |             exit(1);
29 |         }
30 | 
31 |         $generator->write('listener', [
32 |             'baseNamespace' => $this->namespaces['listener'] ?? 'App\\Listeners'
33 |         ]);
34 | 
35 |         echo "\033[0;32mThe event has been well created.\033[00m\n";
36 | 
37 |         exit(0);
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Console/Command/Generator/GenerateExceptionCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Console\Command\Generator;
 6 | 
 7 | use Bow\Console\AbstractCommand;
 8 | use Bow\Console\Generator;
 9 | 
10 | class GenerateExceptionCommand extends AbstractCommand
11 | {
12 |     /**
13 |      * Add middleware
14 |      *
15 |      * @param  string $exception
16 |      * @return void
17 |      */
18 |     public function run(string $exception): void
19 |     {
20 |         $generator = new Generator(
21 |             $this->setting->getExceptionDirectory(),
22 |             $exception
23 |         );
24 | 
25 |         if ($generator->fileExists()) {
26 |             echo "\033[0;31mThe exception already exists.\033[00m\n";
27 | 
28 |             exit(1);
29 |         }
30 | 
31 |         $generator->write('exception', [
32 |             'baseNamespace' => $this->namespaces['exception'] ?? 'App\\Exceptions'
33 |         ]);
34 | 
35 |         echo "\033[0;32mThe exception has been well created.\033[00m\n";
36 | 
37 |         exit(0);
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Console/Command/Generator/GenerateKeyCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Console\Command\Generator;
 6 | 
 7 | use Bow\Console\AbstractCommand;
 8 | use Bow\Console\Color;
 9 | use Bow\Console\Exception\ConsoleException;
10 | 
11 | class GenerateKeyCommand extends AbstractCommand
12 | {
13 |     /**
14 |      * Generate Key
15 |      *
16 |      * @return void
17 |      * @throws ConsoleException
18 |      */
19 |     public function run(): void
20 |     {
21 |         $key = base64_encode(openssl_random_pseudo_bytes(12) . date('Y-m-d H:i:s') . microtime(true));
22 | 
23 |         $env_file = config('app.env_file');
24 | 
25 |         if (!file_exists($env_file)) {
26 |             throw new ConsoleException("The .env.json file not found. Run cp .env.example.json .env.json");
27 |         }
28 | 
29 |         $contents = file_get_contents($env_file);
30 |         $contents = preg_replace('@"APP_KEY"\s*:\s*".*?"@', '"APP_KEY": "' . $key . '"', $contents);
31 | 
32 |         file_put_contents($env_file, $contents);
33 | 
34 |         echo sprintf("Application key => %s\n", Color::green($key));
35 | 
36 |         exit;
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Console/Command/Generator/GenerateMessagingCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Console\Command\Generator;
 6 | 
 7 | use Bow\Console\AbstractCommand;
 8 | use Bow\Console\Color;
 9 | use Bow\Console\Generator;
10 | 
11 | class GenerateMessagingCommand extends AbstractCommand
12 | {
13 |     /**
14 |      * Generate session
15 |      *
16 |      * @param  string $messaging
17 |      * @return void
18 |      */
19 |     public function run(string $messaging): void
20 |     {
21 |         $generator = new Generator(
22 |             $this->setting->getMessagingDirectory(),
23 |             $messaging
24 |         );
25 | 
26 |         if ($generator->fileExists()) {
27 |             echo Color::red("The messaging already exists");
28 | 
29 |             exit(1);
30 |         }
31 | 
32 |         $generator->write('messaging', [
33 |             'baseNamespace' => $this->namespaces['messaging'] ?? "App\\Messaging",
34 |         ]);
35 | 
36 |         echo Color::green("The messaging has been well created.");
37 | 
38 |         exit(0);
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Console/Command/Generator/GenerateMiddlewareCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Console\Command\Generator;
 6 | 
 7 | use Bow\Console\AbstractCommand;
 8 | use Bow\Console\Color;
 9 | use Bow\Console\Generator;
10 | 
11 | class GenerateMiddlewareCommand extends AbstractCommand
12 | {
13 |     /**
14 |      * Add middleware
15 |      *
16 |      * @param  string $middleware
17 |      * @return void
18 |      */
19 |     public function run(string $middleware): void
20 |     {
21 |         $generator = new Generator(
22 |             $this->setting->getMiddlewareDirectory(),
23 |             $middleware
24 |         );
25 | 
26 |         if ($generator->fileExists()) {
27 |             echo Color::red("The middleware already exists");
28 | 
29 |             exit(1);
30 |         }
31 | 
32 |         $generator->write('middleware', [
33 |             'baseNamespace' => $this->namespaces['middleware'] ?? "App\\Middlewares"
34 |         ]);
35 | 
36 |         echo Color::green("The middleware has been well created.");
37 | 
38 |         exit(0);
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Console/Command/Generator/GenerateModelCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Console\Command\Generator;
 6 | 
 7 | use Bow\Console\AbstractCommand;
 8 | use Bow\Console\Color;
 9 | use Bow\Console\Generator;
10 | 
11 | class GenerateModelCommand extends AbstractCommand
12 | {
13 |     /**
14 |      * Add Model
15 |      *
16 |      * @param  string $model
17 |      * @return void
18 |      */
19 |     public function run(string $model): void
20 |     {
21 |         $generator = new Generator(
22 |             $this->setting->getModelDirectory(),
23 |             $model
24 |         );
25 | 
26 |         if ($generator->fileExists()) {
27 |             echo Color::red('The model already exists.');
28 | 
29 |             exit(1);
30 |         }
31 | 
32 |         $generator->write('model/model', [
33 |             'baseNamespace' => $this->namespaces['model']
34 |         ]);
35 | 
36 |         echo Color::green("The model was well created.");
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Console/Command/Generator/GenerateNotificationCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Console\Command\Generator;
 6 | 
 7 | use Bow\Console\AbstractCommand;
 8 | use Bow\Console\Color;
 9 | use Bow\Console\Generator;
10 | use Bow\Support\Str;
11 | 
12 | class GenerateNotificationCommand extends AbstractCommand
13 | {
14 |     /**
15 |      * Generate session
16 |      *
17 |      * @return void
18 |      */
19 |     public function run(): void
20 |     {
21 |         $create_at = date("YmdHis");
22 |         $filename = sprintf("Version%s%sTable", $create_at, ucfirst(Str::camel('notification')));
23 | 
24 |         $generator = new Generator(
25 |             $this->setting->getMigrationDirectory(),
26 |             $filename
27 |         );
28 | 
29 |         $generator->write('model/notification', [
30 |             'className' => $filename
31 |         ]);
32 | 
33 |         echo Color::green('Notification migration created.');
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/Console/Command/Generator/GenerateProducerCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Console\Command\Generator;
 6 | 
 7 | use Bow\Console\AbstractCommand;
 8 | use Bow\Console\Color;
 9 | use Bow\Console\Generator;
10 | 
11 | class GenerateProducerCommand extends AbstractCommand
12 | {
13 |     /**
14 |      * Add producer
15 |      *
16 |      * @param  string $producer
17 |      * @return void
18 |      */
19 |     public function run(string $producer): void
20 |     {
21 |         $generator = new Generator(
22 |             $this->setting->getProducerDirectory(),
23 |             $producer
24 |         );
25 | 
26 |         if ($generator->fileExists()) {
27 |             echo Color::red("The producer already exists");
28 |             exit(1);
29 |         }
30 | 
31 |         $generator->write('producer', [
32 |             'baseNamespace' => $this->namespaces['producer'] ?? 'App\\Producers'
33 |         ]);
34 | 
35 |         echo Color::green("The producer has been well created.");
36 |         exit(0);
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Console/Command/Generator/GenerateQueueCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Console\Command\Generator;
 6 | 
 7 | use Bow\Console\AbstractCommand;
 8 | use Bow\Console\Color;
 9 | use Bow\Console\Generator;
10 | use Bow\Support\Str;
11 | 
12 | class GenerateQueueCommand extends AbstractCommand
13 | {
14 |     /**
15 |      * Generate session
16 |      *
17 |      * @return void
18 |      */
19 |     public function run(): void
20 |     {
21 |         $create_at = date("YmdHis");
22 |         $filename = sprintf("Version%s%sTable", $create_at, ucfirst(Str::camel('queues')));
23 | 
24 |         $generator = new Generator(
25 |             $this->setting->getMigrationDirectory(),
26 |             $filename
27 |         );
28 | 
29 |         $generator->write('model/queue', [
30 |             'className' => $filename
31 |         ]);
32 | 
33 |         echo Color::green('Queue migration created.');
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/Console/Command/Generator/GenerateSeederCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Console\Command\Generator;
 6 | 
 7 | use Bow\Console\AbstractCommand;
 8 | use Bow\Console\Generator;
 9 | use Bow\Console\Traits\ConsoleTrait;
10 | use Bow\Support\Str;
11 | 
12 | class GenerateSeederCommand extends AbstractCommand
13 | {
14 |     use ConsoleTrait;
15 | 
16 |     /**
17 |      * Create a seeder
18 |      *
19 |      * @param string $seeder
20 |      */
21 |     public function run(string $seeder): void
22 |     {
23 |         $seeder = Str::plural($seeder);
24 | 
25 |         $generator = new Generator(
26 |             $this->setting->getSeederDirectory(),
27 |             $seeder
28 |         );
29 | 
30 |         if ($generator->fileExists()) {
31 |             echo "\033[0;31mThe seeder already exists.\033[00m";
32 | 
33 |             exit(1);
34 |         }
35 | 
36 |         $generator->write('seeder', ['name' => $seeder]);
37 | 
38 |         echo "\033[0;32mThe seeder has been created.\033[00m\n";
39 | 
40 |         exit(0);
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/src/Console/Command/Generator/GenerateServiceCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Console\Command\Generator;
 6 | 
 7 | use Bow\Console\AbstractCommand;
 8 | use Bow\Console\Generator;
 9 | 
10 | class GenerateServiceCommand extends AbstractCommand
11 | {
12 |     /**
13 |      * Add service
14 |      *
15 |      * @param  string $service
16 |      * @return void
17 |      */
18 |     public function run(string $service): void
19 |     {
20 |         $generator = new Generator(
21 |             $this->setting->getServiceDirectory(),
22 |             $service
23 |         );
24 | 
25 |         if ($generator->fileExists()) {
26 |             echo "\033[0;31mThe service already exists.\033[00m\n";
27 | 
28 |             exit(1);
29 |         }
30 | 
31 |         $generator->write('service', [
32 |             'baseNamespace' => $this->namespaces['service'] ?? 'App\\Services'
33 |         ]);
34 | 
35 |         echo "\033[0;32mThe service has been well created.\033[00m\n";
36 | 
37 |         exit(0);
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Console/Command/Generator/GenerateSessionCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Console\Command\Generator;
 6 | 
 7 | use Bow\Console\AbstractCommand;
 8 | use Bow\Console\Color;
 9 | use Bow\Console\Generator;
10 | use Bow\Support\Str;
11 | 
12 | class GenerateSessionCommand extends AbstractCommand
13 | {
14 |     /**
15 |      * Generate session
16 |      *
17 |      * @return void
18 |      */
19 |     public function run(): void
20 |     {
21 |         $create_at = date("YmdHis");
22 |         $filename = sprintf("Version%s%sTable", $create_at, ucfirst(Str::camel('sessions')));
23 | 
24 |         $generator = new Generator(
25 |             $this->setting->getMigrationDirectory(),
26 |             $filename
27 |         );
28 | 
29 |         $generator->write('model/session', [
30 |             'className' => $filename
31 |         ]);
32 | 
33 |         echo Color::green('Session migration created.');
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/Console/Command/Generator/GenerateValidationCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Console\Command\Generator;
 6 | 
 7 | use Bow\Console\AbstractCommand;
 8 | use Bow\Console\Color;
 9 | use Bow\Console\Generator;
10 | 
11 | class GenerateValidationCommand extends AbstractCommand
12 | {
13 |     /**
14 |      * Add validation
15 |      *
16 |      * @param  string $validation
17 |      * @return void
18 |      */
19 |     public function run(string $validation): void
20 |     {
21 |         $generator = new Generator(
22 |             $this->setting->getValidationDirectory(),
23 |             $validation
24 |         );
25 | 
26 |         if ($generator->fileExists()) {
27 |             echo Color::red('The validation already exists.');
28 | 
29 |             exit(0);
30 |         }
31 | 
32 |         $generator->write('validation', [
33 |             'baseNamespace' => $this->namespaces['validation']
34 |         ]);
35 | 
36 |         echo Color::green('The validation was created well.');
37 | 
38 |         exit(0);
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Console/Command/ReplCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Console\Command;
 6 | 
 7 | use Bow\Console\AbstractCommand;
 8 | use Bow\Console\Color;
 9 | use Psy\Configuration;
10 | use Psy\Shell;
11 | use Psy\VersionUpdater\Checker;
12 | 
13 | class ReplCommand extends AbstractCommand
14 | {
15 |     /**
16 |      * Launch the REPL console
17 |      *
18 |      * @return void
19 |      */
20 |     public function run(): void
21 |     {
22 |         $include = $this->arg->getParameter('--include');
23 | 
24 |         if (is_string($include)) {
25 |             $bootstraps = array_merge(
26 |                 $this->setting->getBootstrap(),
27 |                 (array) $include
28 |             );
29 | 
30 |             $this->setting->setBootstrap($bootstraps);
31 |         }
32 | 
33 |         if (!class_exists('\Psy\Shell')) {
34 |             echo Color::red('Please, install psy/psysh:@stable');
35 | 
36 |             return;
37 |         }
38 | 
39 |         $config = new Configuration();
40 |         $config->setUpdateCheck(Checker::NEVER);
41 | 
42 |         // Load the custom prompt
43 |         $prompt = $this->arg->getParameter('--prompt', '(bow) >>');
44 |         $prompt = trim($prompt) . ' ';
45 | 
46 |         $config->theme()->setPrompt($prompt);
47 | 
48 |         $shell = new Shell($config);
49 | 
50 |         $shell->setIncludes($this->setting->getBootstrap());
51 |         $shell->run();
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/src/Console/Command/ServerCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Console\Command;
 6 | 
 7 | use Bow\Console\AbstractCommand;
 8 | 
 9 | class ServerCommand extends AbstractCommand
10 | {
11 |     /**
12 |      * The run server command
13 |      *
14 |      * @return void
15 |      */
16 |     public function run(): void
17 |     {
18 |         $port = (int)$this->arg->getParameter('--port', 8080);
19 |         $hostname = $this->arg->getParameter('--host', 'localhost');
20 |         $settings = $this->arg->getParameter('--php-settings', false);
21 | 
22 |         if (is_bool($settings)) {
23 |             $settings = '';
24 |         } else {
25 |             $settings = '-d ' . $settings;
26 |         }
27 | 
28 |         $filename = $this->setting->getServerFilename();
29 |         $public_directory = $this->setting->getPublicDirectory();
30 | 
31 |         // Launch the dev server.
32 |         shell_exec(
33 |             "php -S $hostname:$port -t {$public_directory} " . $filename . " $settings"
34 |         );
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/Console/Command/WorkerCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Console\Command;
 6 | 
 7 | use Bow\Console\AbstractCommand;
 8 | use Bow\Queue\WorkerService;
 9 | 
10 | class WorkerCommand extends AbstractCommand
11 | {
12 |     /**
13 |      * The run server command
14 |      *
15 |      * @param  string|null $connection
16 |      * @return void
17 |      */
18 |     public function run(?string $connection = null): void
19 |     {
20 |         $tries = (int)$this->arg->getParameter('--tries', 3);
21 |         $default = $this->arg->getParameter('--queue', "default");
22 |         $memory = (int)$this->arg->getParameter('--memory', 126);
23 |         $timout = (int)$this->arg->getParameter('--timout', 60);
24 |         $sleep = (int)$this->arg->getParameter('--sleep', 60);
25 | 
26 |         $queue = app("queue");
27 | 
28 |         if (!is_null($connection)) {
29 |             $queue->setConnection($connection);
30 |         }
31 | 
32 |         $worker = $this->getWorderService();
33 |         $worker->setConnection($queue->getAdapter());
34 |         $worker->run($default, $tries, $sleep, $timout, $memory);
35 |     }
36 | 
37 |     /**
38 |      * Get the worker service
39 |      *
40 |      * @return WorkerService
41 |      */
42 |     private function getWorderService()
43 |     {
44 |         return new WorkerService();
45 |     }
46 | 
47 |     /**
48 |      * Flush the queue
49 |      *
50 |      * @param  ?string $connection
51 |      * @return void
52 |      */
53 |     public function flush(?string $connection = null)
54 |     {
55 |         $connection_queue = $this->arg->getParameter('--queue');
56 | 
57 |         $queue = app("queue");
58 | 
59 |         if (!is_null($connection)) {
60 |             $queue->setConnection($connection);
61 |         }
62 | 
63 |         $adapter = $queue->getAdapter();
64 |         $adapter->flush($connection_queue);
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/Console/Exception/ConsoleException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Console\Exception;
 6 | 
 7 | use Exception;
 8 | 
 9 | class ConsoleException extends Exception
10 | {
11 |     // Empty
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Console/README.md:
--------------------------------------------------------------------------------
 1 | # Bow Container
 2 | 
 3 | Bow Framework's console system is very simple and powerful which can help you create controller, model and much mores:
 4 | 
 5 | Let's show the console guide:
 6 | 
 7 | ```bash
 8 | php bow help
 9 | ```
10 | 
11 | Is very joyful api
12 | 


--------------------------------------------------------------------------------
/src/Console/Traits/ConsoleTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Console\Traits;
 6 | 
 7 | use Bow\Console\Color;
 8 | 
 9 | trait ConsoleTrait
10 | {
11 |     /**
12 |      * Throw fails command
13 |      *
14 |      * @param  string      $message
15 |      * @param  string|null $command
16 |      * @return void
17 |      */
18 |     protected function throwFailsCommand(string $message, ?string $command = null): void
19 |     {
20 |         echo Color::red($message) . "\n";
21 | 
22 |         if (!is_null($command)) {
23 |             echo Color::green(sprintf('Type "php bow %s" for more information', $command));
24 |         }
25 | 
26 |         exit(1);
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Console/stubs/command.stub:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace {baseNamespace}{namespace};
 4 | 
 5 | use Bow\Console\AbstractCommand as ConsoleCommand;
 6 | 
 7 | class {className} extends ConsoleCommand
 8 | {
 9 |     /**
10 |      * Handle console action
11 |      * 
12 |      * @return void
13 |      */
14 |     public function process(): void
15 |     {
16 |         //
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Console/stubs/configuration.stub:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace {baseNamespace}{namespace};
 4 | 
 5 | use Bow\Configuration\Loader;
 6 | use Bow\Configuration\Configuration;
 7 | 
 8 | class {className} extends Configuration
 9 | {
10 |     /**
11 |      * Launch configuration
12 |      *
13 |      * @param Loader $config
14 |      * @return void
15 |      */
16 |     public function create(Loader $config): void
17 |     {
18 |         //
19 |     }
20 | 
21 |     /**
22 |      * Start the configured package
23 |      *
24 |      * @return void
25 |      */
26 |     public function run(): void
27 |     {
28 |         //
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Console/stubs/controller/controller.stub:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace {baseNamespace}{namespace};
 4 | 
 5 | use {baseNamespace}\Controller;
 6 | use Bow\Http\Request;
 7 | 
 8 | class {className} extends Controller
 9 | {
10 |     //
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Console/stubs/controller/no-plain.stub:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace {baseNamespace}{namespace};
 4 | 
 5 | use {baseNamespace}\Controller;
 6 | use Bow\Http\Request;
 7 | 
 8 | class {className} extends Controller
 9 | {
10 |     /**
11 |      * Application entry point
12 |      *
13 |      * @return void
14 |      */
15 |     public function index(): void
16 |     {
17 |         // Code Here
18 |     }
19 | 
20 |     /**
21 |      * Displays the view for creating a resource.
22 |      *
23 |      * @param Request $request
24 |      * @return void
25 |      */
26 |     public function create(): void
27 |     {
28 |         // Code Here
29 |     }
30 | 
31 |     /**
32 |      * Add a new resource in the information base
33 |      *
34 |      * @param Request $request
35 |      * @return void
36 |      */
37 |     public function store(Request $request): void
38 |     {
39 |         // Code Here
40 |     }
41 | 
42 |     /**
43 |      * Allows you to retrieve precise information with an identifier.
44 |      *
45 |      * @param  mixed $id
46 |      * @return void
47 |      */
48 |     public function show(mixed $id): void
49 |     {
50 |         // Code Here
51 |     }
52 | 
53 |     /**
54 |      * Show updating form using GET
55 |      *
56 |      * @param  mixed $id
57 |      * @return void
58 |      */
59 |     public function edit(mixed $id): void
60 |     {
61 |         // Code Here
62 |     }
63 | 
64 |     /**
65 |      * Update a resource
66 |      *
67 |      * @param Request $request
68 |      * @param  mixed $id
69 |      * @return void
70 |      */
71 |     public function update(Request $request, mixed $id): void
72 |     {
73 |         // Code Here
74 |     }
75 | 
76 |     /**
77 |      * Delete a resource
78 |      *
79 |      * @param mixed $id
80 |      * @return void
81 |      */
82 |     public function destroy(mixed $id): void
83 |     {
84 |         // Code Here
85 |     }
86 | }
87 | 


--------------------------------------------------------------------------------
/src/Console/stubs/controller/rest.stub:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace {baseNamespace}{namespace};
 4 | 
 5 | {modelNamespace}use {baseNamespace}\Controller;
 6 | use Bow\Http\Request;
 7 | 
 8 | class {className} extends Controller
 9 | {
10 |     /**
11 |      * Start point
12 |      *
13 |      * GET {prefix}
14 |      *
15 |      * @return void
16 |      */
17 |     public function index(): void
18 |     {
19 |         // Code Here
20 |     }
21 | 
22 |     /**
23 |      * Add a new resource in the information base
24 |      *
25 |      * POST {prefix}
26 |      *
27 |      * @param Request $request
28 |      * @return void
29 |      */
30 |     public function store(Request $request): void
31 |     {
32 |         // Code Here
33 |     }
34 | 
35 |     /**
36 |      * Allows you to retrieve specific information with an identifier.
37 |      *
38 |      * GET {prefix}/:id
39 |      *
40 |      * @param Request $request
41 |      * @param mixed $id
42 |      * @return void
43 |      */
44 |     public function show(Request $request, mixed $id): void
45 |     {
46 |         // Code Here
47 |     }
48 | 
49 |     /**
50 |      * Updating a resource
51 |      *
52 |      * PUT {prefix}/:id
53 |      *
54 |      * @param Request $request
55 |      * @param mixed $id
56 |      * @return void
57 |      */
58 |     public function update(Request $request, mixed $id): void
59 |     {
60 |         // Code Here
61 |     }
62 | 
63 |     /**
64 |      * Delete a resource
65 |      *
66 |      * DELETE {prefix}/:id
67 |      *
68 |      * @param Request $request
69 |      * @param mixed $id
70 |      * @return void
71 |      */
72 |     public function destroy(Request $request, mixed $id): void
73 |     {
74 |         // Code Here
75 |     }
76 | }
77 | 


--------------------------------------------------------------------------------
/src/Console/stubs/controller/service.stub:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace {baseNamespace}{namespace};
 4 | 
 5 | use {baseNamespace}\Controller;
 6 | use Bow\Http\Request;
 7 | use {serviceNamespace}\{serviceClassName};
 8 | 
 9 | class {className} extends Controller
10 | {
11 | 	/**
12 | 	 * Instance of {serviceClassName}
13 | 	 * 
14 | 	 * @var {serviceClassName}
15 | 	 */
16 | 	private {serviceClassName} ${serviceName};
17 | 
18 | 	/**
19 | 	 * {className} constructor
20 | 	 * 
21 | 	 * @param {serviceClassName} ${serviceName}
22 | 	 * @return mixed
23 | 	 */
24 |     public function __construct(
25 |         private {serviceClassName} ${serviceName}
26 |     ){
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Console/stubs/event.stub:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace {baseNamespace}{namespace};
 4 | 
 5 | use Bow\Event\Contracts\AppEvent;
 6 | use Bow\Event\Dispatchable;
 7 | use Bow\Support\Serializes;
 8 | 
 9 | class {className} implements AppEvent
10 | {
11 | 	use Dispatchable, Serializes;
12 | 
13 |     /**
14 |      * Create a new event instance.
15 |      */
16 |     public function __construct()
17 |     {
18 |         // Do something here
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Console/stubs/exception.stub:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace {baseNamespace}{namespace};
 4 | 
 5 | use Exception;
 6 | 
 7 | class {className} extends Exception
 8 | {
 9 |     // do something here
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Console/stubs/listener.stub:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace {baseNamespace}{namespace};
 4 | 
 5 | use Bow\Event\Contracts\EventListener;
 6 | 
 7 | class {className} implements EventListener
 8 | {
 9 | 	/**
10 | 	 * Process the event
11 | 	 * 
12 | 	 * @param mixed $event
13 | 	 * @return void
14 | 	 */
15 | 	public function process($event): void
16 | 	{
17 |         // do something here
18 | 	}
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Console/stubs/messaging.stub:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace {baseNamespace}{namespace};
 4 | 
 5 | use Bow\Database\Barry\Model;
 6 | use Bow\Mail\Envelop;
 7 | use Bow\Messaging\Messaging;
 8 | 
 9 | class {className} extends Messaging
10 | {
11 |     /**
12 |      * Returns the available channels to be used
13 |      *
14 |      * @param Model $notifiable
15 |      * @return array
16 |      */
17 |     public function channels(Model $notifiable): array
18 |     {
19 |         return ['mail', 'database'];
20 |     }
21 | 
22 |     /**
23 |      * Send notification to mail
24 |      *
25 |      * @param Model $notifiable
26 |      * @return Envelop|null
27 |      */
28 |     public function toMail(Model $notifiable): ?Envelop
29 |     {
30 |         return (new Envelop());
31 |     }
32 | 
33 |     /**
34 |      * Send notification to database
35 |      *
36 |      * @param Model $notifiable
37 |      * @return array
38 |      */
39 |     public function toDatabase(Model $notifiable): array
40 |     {
41 |         return [];
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/Console/stubs/middleware.stub:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace {baseNamespace}{namespace};
 4 | 
 5 | use Bow\Http\Request;
 6 | use Bow\Middleware\BaseMiddleware;
 7 | 
 8 | class {className} implements BaseMiddleware
 9 | {
10 |     /**
11 |      * Handle an incoming request.
12 |      *
13 |      * @param Request $request
14 |      * @param callable $next
15 |      * @param array $args
16 |      * @return mixed
17 |      */
18 |     public function process(Request $request, callable $next, array $args = []): mixed
19 |     {
20 |         // Code Here
21 | 
22 |         return $next($request);
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Console/stubs/model/cache.stub:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Bow\Database\Migration\Migration;
 4 | use Bow\Database\Migration\Table;
 5 | 
 6 | class {className} extends Migration
 7 | {
 8 |     /**
 9 |      * Up Migration
10 |      */
11 |     public function up(): void
12 |     {
13 |         $this->create("caches", function (Table $table) {
14 |             $table->addString('key_name', ['primary' => true, 'size' => 500]);
15 |             $table->addText('data');
16 |             $table->addDatetime('expire', ['nullable' => true]);
17 |             $table->addTimestamps();
18 |         });
19 |     }
20 | 
21 |     /**
22 |      * Rollback migration
23 |      */
24 |     public function rollback(): void
25 |     {
26 |         $this->dropIfExists("caches");
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Console/stubs/model/create.stub:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Bow\Database\Migration\Migration;
 4 | use Bow\Database\Migration\Table;
 5 | 
 6 | class {className} extends Migration
 7 | {
 8 |     /**
 9 |      * Up Migration
10 |      */
11 |     public function up(): void
12 |     {
13 |         $this->create("{table}", function (Table $table) {
14 |             $table->addIncrement('id');
15 |             $table->addTimestamps();
16 |         });
17 |     }
18 | 
19 |     /**
20 |      * Rollback migration
21 |      */
22 |     public function rollback(): void
23 |     {
24 |         $this->dropIfExists("{table}");
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Console/stubs/model/model.stub:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace {baseNamespace}{namespace};
 4 | 
 5 | use Bow\Database\Barry\Model;
 6 | 
 7 | class {className} extends Model
 8 | {
 9 |     //
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Console/stubs/model/notification.stub:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Bow\Database\Migration\Migration;
 4 | use Bow\Database\Migration\Table;
 5 | 
 6 | class {className} extends Migration
 7 | {
 8 |     /**
 9 |      * Up Migration
10 |      */
11 |     public function up(): void
12 |     {
13 |         $this->create("notifications", function (Table $table) {
14 |             $table->addString('id', ["primary" => true]);
15 |             $table->addString('type');
16 |             $table->addString('concern_id');
17 |             $table->addString('concern_type');
18 |             $table->addText('data');
19 |             $table->addDatetime('read_at', ['nullable' => true]);
20 |             $table->addTimestamps();
21 |         });
22 |     }
23 | 
24 |     /**
25 |      * Rollback migration
26 |      */
27 |     public function rollback(): void
28 |     {
29 |         $this->dropIfExists("notifications");
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Console/stubs/model/queue.stub:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Bow\Database\Migration\Migration;
 4 | use Bow\Database\Migration\Table;
 5 | 
 6 | class {className} extends Migration
 7 | {
 8 |     /**
 9 |      * Up Migration
10 |      */
11 |     public function up(): void
12 |     {
13 |         $this->create("queues", function (Table $table) {
14 |             $table->addString('id', ["primary" => true]);
15 |             $table->addString('queue');
16 |             $table->addText('payload');
17 |             $table->addInteger('attempts', ["default" => 3]);
18 |             $table->addEnum('status', [
19 |                 "size" => ["waiting", "processing", "reserved", "failed", "done"],
20 |                 "default" => "waiting",
21 |             ]);
22 |             $table->addDatetime('available_at');
23 |             $table->addDatetime('reserved_at', ["nullable" => true, "default" => null]);
24 |             $table->addDatetime('created_at');
25 |         });
26 |     }
27 | 
28 |     /**
29 |      * Rollback migration
30 |      */
31 |     public function rollback(): void
32 |     {
33 |         $this->dropIfExists("queues");
34 | 
35 |         if ($this->getAdapterName() === 'pgsql') {
36 |             $this->addSql("DROP TYPE IF EXISTS queue_status");
37 |         }
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Console/stubs/model/session.stub:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Bow\Database\Migration\Migration;
 4 | use Bow\Database\Migration\Table;
 5 | 
 6 | class {className} extends Migration
 7 | {
 8 |     /**
 9 |      * Up Migration
10 |      */
11 |     public function up(): void
12 |     {
13 |         $this->create("sessions", function (Table $table) {
14 |             $table->addColumn('id', 'string', ['primary' => true]);
15 |             $table->addColumn('time', 'timestamp');
16 |             $table->addColumn('data', 'text');
17 |             $table->addColumn('ip', 'string');
18 |         });
19 |     }
20 | 
21 |     /**
22 |      * Rollback migration
23 |      */
24 |     public function rollback(): void
25 |     {
26 |         $this->dropIfExists("sessions");
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Console/stubs/model/standard.stub:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Bow\Database\Migration\Migration;
 4 | use Bow\Database\Migration\Table;
 5 | 
 6 | class {className} extends Migration
 7 | {
 8 |     /**
 9 |      * Up Migration
10 |      */
11 |     public function up(): void
12 |     {
13 |         $this->create("{table}", function (Table $table) {
14 |             //
15 |         });
16 |     }
17 | 
18 |     /**
19 |      * Rollback migration
20 |      */
21 |     public function rollback(): void
22 |     {
23 |         $this->dropIfExists("{table}");
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Console/stubs/model/table.stub:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Bow\Database\Migration\Migration;
 4 | use Bow\Database\Migration\Table;
 5 | 
 6 | class {className} extends Migration
 7 | {
 8 |     /**
 9 |      * Up Migration
10 |      */
11 |     public function up(): void
12 |     {
13 |         $this->alter("{table}", function (Table $table) {
14 |             //
15 |         });
16 |     }
17 | 
18 |     /**
19 |      * Rollback migration
20 |      */
21 |     public function rollback(): void
22 |     {
23 |         $this->alter("{table}", function (SQLGenerator $table) {
24 |             //
25 |         });
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Console/stubs/producer.stub:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace {baseNamespace}{namespace};
 4 | 
 5 | use Bow\Queue\ProducerService;
 6 | 
 7 | class {className} extends ProducerService
 8 | {
 9 |     /**
10 |      * {className} constructor
11 |      * 
12 |      * @return void
13 |      */
14 |     public function __construct()
15 |     {
16 |         //
17 |     }
18 | 
19 | 	/**
20 | 	 * Handle producer
21 | 	 * 
22 | 	 * @return void
23 | 	 */
24 |     public function process(): void
25 |     {
26 | 	    // Do Something
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Console/stubs/seeder.stub:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Faker\Factory as FakerFactory;
 4 | 
 5 | /**
 6 |  * The {name} seeder
 7 |  *
 8 |  * @see https://fakerphp.github.io for all documentation
 9 |  */
10 | $faker = FakerFactory::create();
11 | 
12 | $seed = [
13 |     'name' => $faker->name(),
14 |     'created_at' => date('Y-m-d H:i:s'),
15 |     'updated_at' => date('Y-m-d H:i:s')
16 | ];
17 | 
18 | return ['{name}' => $seed];
19 | 


--------------------------------------------------------------------------------
/src/Console/stubs/service.stub:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace {baseNamespace}{namespace};
4 | 
5 | class {className}
6 | {
7 |     // Do Something
8 | }
9 | 


--------------------------------------------------------------------------------
/src/Console/stubs/validation.stub:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace {baseNamespace}{namespace};
 4 | 
 5 | use Bow\Validation\RequestValidation;
 6 | 
 7 | class {className} extends RequestValidation
 8 | {
 9 | 	/**
10 | 	 * Validation rules
11 | 	 *
12 | 	 * @return array
13 | 	 */
14 |     protected function rules(): array
15 |     {
16 | 	    return [
17 |             // Your roles here
18 |         ];
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Container/ContainerConfiguration.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Container;
 6 | 
 7 | use Bow\Configuration\Configuration;
 8 | use Bow\Configuration\Loader;
 9 | 
10 | class ContainerConfiguration extends Configuration
11 | {
12 |     /**
13 |      * @var array
14 |      */
15 |     private array $middlewares = [
16 |         //
17 |     ];
18 | 
19 |     /**
20 |      * @inheritdoc
21 |      */
22 |     public function create(Loader $config): void
23 |     {
24 |         $this->container->bind(
25 |             'action',
26 |             function () use ($config) {
27 |                 $middlewares = array_merge($config->getMiddlewares(), $this->middlewares);
28 | 
29 |                 return Compass::configure($config->namespaces(), $middlewares);
30 |             }
31 |         );
32 |     }
33 | 
34 |     /**
35 |      * @inheritdoc
36 |      */
37 |     public function run(): void
38 |     {
39 |         $this->container->make('action');
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/Container/README.md:
--------------------------------------------------------------------------------
 1 | # Bow Container
 2 | 
 3 | Bow Framework's container system is very simple and powerful class dependences building:
 4 | 
 5 | Let's show a little exemple:
 6 | 
 7 | ```php
 8 | use App\Application;
 9 | use Bow\Containers\Capsule;
10 | 
11 | $capsule = Capsule::getInstance();
12 | 
13 | $capsule->bind(Application::class, function ($config) {
14 |     return Application::make($config);
15 | });
16 | 
17 | $app = $capsule->make(Application::class);
18 | $app->run();
19 | ```
20 | 
21 | Is very enjoyful api
22 | 


--------------------------------------------------------------------------------
/src/Contracts/CollectionInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Contracts;
 6 | 
 7 | interface CollectionInterface
 8 | {
 9 |     /**
10 |      * Check for existence of a key in the session collection
11 |      *
12 |      * @param  string|int $key
13 |      * @return bool
14 |      */
15 |     public function has(string|int $key): bool;
16 | 
17 |     /**
18 |      * Check if a collection is empty.
19 |      *
20 |      * @return bool
21 |      */
22 |     public function isEmpty(): bool;
23 | 
24 |     /**
25 |      * Allows to recover a value or value collection.
26 |      *
27 |      * @param  string $key
28 |      * @param  mixed  $default
29 |      * @return mixed
30 |      */
31 |     public function get(mixed $key, mixed $default = null): mixed;
32 | 
33 |     /**
34 |      * Add an entry to the collection
35 |      *
36 |      * @param  string|int $key
37 |      * @param  mixed      $data
38 |      * @param  bool       $next
39 |      * @return CollectionInterface
40 |      */
41 |     public function add(string|int $key, mixed $data, bool $next = false): mixed;
42 | 
43 | 
44 |     /**
45 |      * Delete an entry in the collection
46 |      *
47 |      * @param  string|int $key
48 |      * @return CollectionInterface
49 |      */
50 |     public function remove(string|int $key): mixed;
51 | 
52 |     /**
53 |      * Modify an entry in the collection
54 |      *
55 |      * @param  string $key
56 |      * @param  mixed  $value
57 |      * @return CollectionInterface
58 |      */
59 |     public function set(string $key, mixed $value): mixed;
60 | 
61 |     /**
62 |      * Return all the entries of the collection as an array
63 |      *
64 |      * @return array
65 |      */
66 |     public function toArray(): array;
67 | 
68 |     /**
69 |      * Return all entries of the collection as an object
70 |      *
71 |      * @return array
72 |      */
73 |     public function toObject(): array;
74 | }
75 | 


--------------------------------------------------------------------------------
/src/Contracts/ResponseInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Contracts;
 6 | 
 7 | interface ResponseInterface
 8 | {
 9 |     /**
10 |      * Send Response to client
11 |      *
12 |      * @return void
13 |      */
14 |     public function sendContent(): void;
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Database/Barry/Relations/BelongsToMany.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Database\Barry\Relations;
 6 | 
 7 | use Bow\Database\Barry\Model;
 8 | use Bow\Database\Barry\Relation;
 9 | use Bow\Database\Collection;
10 | use Bow\Database\Exception\QueryBuilderException;
11 | 
12 | class BelongsToMany extends Relation
13 | {
14 |     /**
15 |      * Create a new belongs to relationship instance.
16 |      *
17 |      * @param Model  $related
18 |      * @param Model  $parent
19 |      * @param string $foreign_key
20 |      * @param string $local_key
21 |      */
22 |     public function __construct(Model $related, Model $parent, string $foreign_key, string $local_key)
23 |     {
24 |         $this->local_key = $local_key;
25 |         $this->foreign_key = $foreign_key;
26 | 
27 |         parent::__construct($related, $parent);
28 |     }
29 | 
30 |     /**
31 |      * Get the results of the relationship.
32 |      *
33 |      * @return Collection
34 |      */
35 |     public function getResults(): Collection
36 |     {
37 |         return $this->query->get();
38 |     }
39 | 
40 |     /**
41 |      * Set the base constraints on the relation query.
42 |      *
43 |      * @return void
44 |      * @throws QueryBuilderException
45 |      */
46 |     public function addConstraints(): void
47 |     {
48 |         if (!static::$has_constraints) {
49 |             return;
50 |         }
51 | 
52 |         // For belongs to relationships, which are essentially the inverse of has one
53 |         // or has many relationships, we need to actually query on the primary key
54 |         // of the related models matching on the foreign key that's on a parent.
55 |         $foreign_key_value = $this->parent->getAttribute($this->foreign_key);
56 |         $this->query->where($this->local_key, '=', $foreign_key_value);
57 |     }
58 | }
59 | 


--------------------------------------------------------------------------------
/src/Database/Barry/Relations/HasMany.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Database\Barry\Relations;
 6 | 
 7 | use Bow\Database\Barry\Model;
 8 | use Bow\Database\Barry\Relation;
 9 | use Bow\Database\Collection;
10 | use Bow\Database\Exception\QueryBuilderException;
11 | 
12 | class HasMany extends Relation
13 | {
14 |     /**
15 |      * Create a new belongs to relationship instance.
16 |      *
17 |      * @param  Model  $related
18 |      * @param  Model  $parent
19 |      * @param  string $foreign_key
20 |      * @param  string $local_key
21 |      * @throws QueryBuilderException
22 |      */
23 |     public function __construct(Model $related, Model $parent, string $foreign_key, string $local_key)
24 |     {
25 |         parent::__construct($related, $parent);
26 | 
27 |         $this->local_key = $local_key;
28 |         $this->foreign_key = $foreign_key;
29 | 
30 |         $this->query = $this->query->where($this->foreign_key, $this->parent->getKeyValue());
31 |     }
32 | 
33 |     /**
34 |      * Get the results of the relationship.
35 |      *
36 |      * @return Collection
37 |      */
38 |     public function getResults(): Collection
39 |     {
40 |         return $this->query->get();
41 |     }
42 | 
43 |     /**
44 |      * Set the base constraints on the relation query.
45 |      *
46 |      * @return void
47 |      */
48 |     public function addConstraints(): void
49 |     {
50 |         //
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/src/Database/Barry/Traits/ArrayAccessTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Database\Barry\Traits;
 6 | 
 7 | trait ArrayAccessTrait
 8 | {
 9 |     /**
10 |      * _offsetSet
11 |      *
12 |      * @param mixed $offset
13 |      * @param mixed $value
14 |      *
15 |      * @see http://php.net/manual/fr/class.arrayaccess.php
16 |      */
17 |     public function offsetSet(mixed $offset, mixed $value): void
18 |     {
19 |         if (is_null($offset)) {
20 |             $this->attributes[] = $value;
21 |         } else {
22 |             $this->attributes[$offset] = $value;
23 |         }
24 |     }
25 | 
26 |     /**
27 |      * _offsetExists
28 |      *
29 |      * @param  mixed $offset
30 |      * @return bool
31 |      * @see    http://php.net/manual/fr/class.arrayaccess.php
32 |      */
33 |     public function offsetExists(mixed $offset): bool
34 |     {
35 |         return isset($this->attributes[$offset]);
36 |     }
37 | 
38 |     /**
39 |      * _offsetUnset
40 |      *
41 |      * @param mixed $offset
42 |      *
43 |      * @see http://php.net/manual/fr/class.arrayaccess.php
44 |      */
45 |     public function offsetUnset(mixed $offset): void
46 |     {
47 |         unset($this->attributes[$offset]);
48 |     }
49 | 
50 |     /**
51 |      * _offsetGet
52 |      *
53 |      * @param  mixed $offset
54 |      * @return mixed|null
55 |      *
56 |      * @see http://php.net/manual/fr/class.arrayaccess.php
57 |      */
58 |     public function offsetGet(mixed $offset): mixed
59 |     {
60 |         return $this->attributes[$offset] ?? null;
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/src/Database/Barry/Traits/CanSerialized.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Database\Barry\Traits;
 6 | 
 7 | use Bow\Database\Barry\Model;
 8 | 
 9 | /**
10 |  * @method toArray(): array
11 |  */
12 | trait CanSerialized
13 | {
14 |     /**
15 |      * __sleep
16 |      *
17 |      * @return array
18 |      */
19 |     public function __sleep(): array
20 |     {
21 |         if ($this instanceof Model) {
22 |             return ['attributes' => $this->attributes];
23 |         }
24 | 
25 |         return ['attributes' => $this->toArray()];
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Database/Barry/Traits/EventTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Database\Barry\Traits;
 6 | 
 7 | use Bow\Support\Str;
 8 | 
 9 | trait EventTrait
10 | {
11 |     /**
12 |      * Fire event
13 |      *
14 |      * @param string $event
15 |      */
16 |     private function fireEvent(string $event): void
17 |     {
18 |         $env = static::formatEventName($event);
19 | 
20 |         if (event()->bound($env)) {
21 |             event()->emit($env, $this);
22 |         }
23 |     }
24 | 
25 |     /**
26 |      * Get event name
27 |      *
28 |      * @param  string $event
29 |      * @return string
30 |      */
31 |     private static function formatEventName(string $event): string
32 |     {
33 |         $class_name = str_replace('\\', '', strtolower(Str::snake(static::class)));
34 | 
35 |         return sprintf("%s.%s", $class_name, strtolower($event));
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/Database/Barry/Traits/SerializableTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Database\Barry\Traits;
 6 | 
 7 | trait SerializableTrait
 8 | {
 9 |     /**
10 |      * Serialize model
11 |      *
12 |      * @return array
13 |      */
14 |     public function __serialize(): array
15 |     {
16 |         return $this->attributes ?? [];
17 |     }
18 | 
19 |     /**
20 |      * Unserialize
21 |      *
22 |      * @param array $attributes
23 |      */
24 |     public function __unserialize(array $attributes): void
25 |     {
26 |         $this->setAttributes($attributes);
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Database/Collection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Database;
 6 | 
 7 | use Bow\Database\Barry\Model;
 8 | use Bow\Support\Collection as SupportCollection;
 9 | 
10 | class Collection extends SupportCollection
11 | {
12 |     /**
13 |      * @inheritdoc
14 |      */
15 |     public function __construct(array $storage = [])
16 |     {
17 |         parent::__construct($storage);
18 |     }
19 | 
20 |     /**
21 |      * Get the first item of storage
22 |      *
23 |      * @return ?Model
24 |      */
25 |     public function first(): ?Model
26 |     {
27 |         $result = parent::first();
28 | 
29 |         return $result !== false ? $result : null;
30 |     }
31 | 
32 |     /**
33 |      * @inheritdoc
34 |      */
35 |     public function toJson(int $option = 0): string
36 |     {
37 |         $data = [];
38 | 
39 |         foreach ($this->toArray() as $model) {
40 |             $data[] = $model->toArray();
41 |         }
42 | 
43 |         return json_encode($data, $option = 0);
44 |     }
45 | 
46 |     /**
47 |      * @inheritdoc
48 |      */
49 |     public function toArray(): array
50 |     {
51 |         $arr = [];
52 | 
53 |         foreach ($this->storage as $value) {
54 |             $arr[] = $value->toArray();
55 |         }
56 | 
57 |         return $arr;
58 |     }
59 | 
60 |     /**
61 |      * Allows you to delete all the selected recordings
62 |      *
63 |      * @return void
64 |      */
65 |     public function dropAll(): void
66 |     {
67 |         $this->each(
68 |             function (Model $model) {
69 |                 $model->delete();
70 |             }
71 |         );
72 |     }
73 | 
74 |     /**
75 |      * @inheritdoc
76 |      */
77 |     public function __toString(): string
78 |     {
79 |         return json_encode($this->all());
80 |     }
81 | 
82 |     /**
83 |      * @inheritdoc
84 |      */
85 |     public function jsonSerialize(): array
86 |     {
87 |         return $this->all();
88 |     }
89 | }
90 | 


--------------------------------------------------------------------------------
/src/Database/Connection/Adapters/SqliteAdapter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Database\Connection\Adapters;
 6 | 
 7 | use Bow\Database\Connection\AbstractConnection;
 8 | use InvalidArgumentException;
 9 | use PDO;
10 | 
11 | class SqliteAdapter extends AbstractConnection
12 | {
13 |     /**
14 |      * The connexion name
15 |      *
16 |      * @var ?string
17 |      */
18 |     protected ?string $name = 'sqlite';
19 | 
20 |     /**
21 |      * SqliteAdapter constructor.
22 |      *
23 |      * @param array $config
24 |      */
25 |     public function __construct(array $config)
26 |     {
27 |         $this->config = $config;
28 | 
29 |         $this->connection();
30 |     }
31 | 
32 |     /**
33 |      * @inheritDoc
34 |      */
35 |     public function connection(): void
36 |     {
37 |         if (!isset($this->config['driver'])) {
38 |             throw new InvalidArgumentException("Please select the right sqlite driver");
39 |         }
40 | 
41 |         if (!isset($this->config['database'])) {
42 |             throw new InvalidArgumentException('The database is not defined');
43 |         }
44 | 
45 |         // Build the PDO connection
46 |         $this->pdo = new PDO('sqlite:' . $this->config['database']);
47 | 
48 |         $this->pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
49 |         $this->pdo->setAttribute(PDO::ATTR_ORACLE_NULLS, PDO::NULL_EMPTY_STRING);
50 |         $this->pdo->setAttribute(
51 |             PDO::ATTR_DEFAULT_FETCH_MODE,
52 |             $this->config['fetch'] ?? $this->fetch
53 |         );
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/src/Database/Connection/Connection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Database\Connection;
 6 | 
 7 | class Connection
 8 | {
 9 |     /**
10 |      * The adaptor information
11 |      *
12 |      * @var AbstractConnection
13 |      */
14 |     private AbstractConnection $adapter;
15 | 
16 |     /**
17 |      * Connection constructor.
18 |      *
19 |      * @param AbstractConnection $adapter
20 |      */
21 |     public function __construct(AbstractConnection $adapter)
22 |     {
23 |         $this->adapter = $adapter;
24 |     }
25 | 
26 |     /**
27 |      * Returns the connection to a database.
28 |      *
29 |      * @return AbstractConnection
30 |      */
31 |     public function getAdapter(): AbstractConnection
32 |     {
33 |         return $this->adapter;
34 |     }
35 | 
36 |     /**
37 |      * Set the adaptor
38 |      *
39 |      * @param AbstractConnection $adapter
40 |      */
41 |     public function setAdapter(AbstractConnection $adapter): void
42 |     {
43 |         $this->adapter = $adapter;
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/Database/DatabaseConfiguration.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Database;
 6 | 
 7 | use Bow\Configuration\Configuration;
 8 | use Bow\Configuration\Loader;
 9 | 
10 | class DatabaseConfiguration extends Configuration
11 | {
12 |     /**
13 |      * @inheritdoc
14 |      */
15 |     public function create(Loader $config): void
16 |     {
17 |         $this->container->bind(
18 |             'db',
19 |             function () use ($config) {
20 |                 return Database::configure($config['database'] ?? $config['db']);
21 |             }
22 |         );
23 |     }
24 | 
25 |     /**
26 |      * @inheritdoc
27 |      */
28 |     public function run(): void
29 |     {
30 |         $this->container->make('db');
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Database/Exception/ConnectionException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Database\Exception;
 6 | 
 7 | use ErrorException;
 8 | 
 9 | class ConnectionException extends ErrorException
10 | {
11 |     // Empty
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Database/Exception/DatabaseException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Database\Exception;
 6 | 
 7 | use PDOException;
 8 | 
 9 | class DatabaseException extends PDOException
10 | {
11 |     // Empty
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Database/Exception/MigrationException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Database\Exception;
 4 | 
 5 | use Exception;
 6 | 
 7 | class MigrationException extends Exception
 8 | {
 9 |     //
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Database/Exception/ModelException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Database\Exception;
 6 | 
 7 | use ErrorException;
 8 | 
 9 | class ModelException extends ErrorException
10 | {
11 |     // Empty
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Database/Exception/NotFoundException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Database\Exception;
 6 | 
 7 | use ErrorException;
 8 | 
 9 | class NotFoundException extends ErrorException
10 | {
11 |     // Empty
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Database/Exception/QueryBuilderException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Database\Exception;
 6 | 
 7 | use ErrorException;
 8 | 
 9 | class QueryBuilderException extends ErrorException
10 | {
11 |     // Empty
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Database/Exception/SQLGeneratorException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Database\Exception;
 4 | 
 5 | use Exception;
 6 | 
 7 | class SQLGeneratorException extends Exception
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/Database/Notification/DatabaseNotification.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Database\Notification;
 4 | 
 5 | use Bow\Database\Barry\Model;
 6 | use Bow\Database\Database;
 7 | 
 8 | class DatabaseNotification extends Model
 9 | {
10 |     /**
11 |      * Cast data as json
12 |      *
13 |      * @var array|string[]
14 |      */
15 |     protected array $casts = [
16 |         'data' => 'array',
17 |     ];
18 | 
19 |     /**
20 |      * The table name
21 |      *
22 |      * @var string
23 |      */
24 |     protected string $table = "notifications";
25 | 
26 |     public function __construct(array $attributes = [])
27 |     {
28 |         parent::__construct($attributes);
29 | 
30 |         $this->table = config('notification.table') ?: 'notifications';
31 |     }
32 | 
33 |     /**
34 |      * Mark notification as read
35 |      *
36 |      * @return bool|int
37 |      */
38 |     public function markAsRead(): bool|int
39 |     {
40 |         return $this->update(['read_at' => app_now()]);
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/src/Database/Notification/WithNotification.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Database\Notification;
 4 | 
 5 | use Bow\Database\Exception;
 6 | use Bow\Database\Exception\ConnectionException;
 7 | 
 8 | trait WithNotification
 9 | {
10 |     /**
11 |      * @throws ConnectionException|Exception\QueryBuilderException
12 |      */
13 |     public function notifications()
14 |     {
15 |         return (new DatabaseNotification())
16 |             ->where('concern_id', $this->getKeyValue())
17 |             ->where('concern_type', get_class($this));
18 |     }
19 | 
20 |     /**
21 |      * @throws ConnectionException|Exception\QueryBuilderException
22 |      */
23 |     public function unreadNotifications()
24 |     {
25 |         return $this->notifications()->whereNull('read_at');
26 |     }
27 | 
28 |     /**
29 |      * @throws ConnectionException|Exception\QueryBuilderException
30 |      */
31 |     public function markAsRead(string $notification_id)
32 |     {
33 |         return $this->notifications()->where('id', $notification_id)->update(['read_at' => app_now()]);
34 |     }
35 | 
36 |     /**
37 |      * @throws ConnectionException|Exception\QueryBuilderException
38 |      */
39 |     public function markAllAsRead()
40 |     {
41 |         return $this->notifications()->update(['read_at' => app_now()]);
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/Event/Contracts/AppEvent.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Event\Contracts;
 6 | 
 7 | interface AppEvent
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/Event/Contracts/EventListener.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Event\Contracts;
 6 | 
 7 | interface EventListener
 8 | {
 9 |     /**
10 |      * Process the event
11 |      *
12 |      * @param  AppEvent $event
13 |      * @return mixed
14 |      */
15 |     public function process(AppEvent $event): void;
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Event/Contracts/EventShouldQueue.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace Bow\Event\Contracts;
4 | 
5 | interface EventShouldQueue
6 | {
7 | }
8 | 


--------------------------------------------------------------------------------
/src/Event/Dispatchable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Event;
 4 | 
 5 | trait Dispatchable
 6 | {
 7 |     /**
 8 |      * Dispatch the event with the given arguments.
 9 |      *
10 |      * @return mixed
11 |      */
12 |     public static function dispatch(): mixed
13 |     {
14 |         return event(new static(...func_get_args()));
15 |     }
16 | 
17 |     /**
18 |      * Dispatch the event with the given arguments if the given truth test passes.
19 |      *
20 |      * @param  bool  $boolean
21 |      * @param  mixed ...$arguments
22 |      * @return void
23 |      */
24 |     public static function dispatchIf(bool $boolean, ...$arguments): void
25 |     {
26 |         if ($boolean) {
27 |             event(new static(...$arguments));
28 |         }
29 |     }
30 | 
31 |     /**
32 |      * Dispatch the event with the given arguments unless the given truth test passes.
33 |      *
34 |      * @param  bool  $boolean
35 |      * @param  mixed ...$arguments
36 |      * @return void
37 |      */
38 |     public static function dispatchUnless(bool $boolean, ...$arguments): void
39 |     {
40 |         if (!$boolean) {
41 |             event(new static(...$arguments));
42 |         }
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/src/Event/EventException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Event;
 6 | 
 7 | use ErrorException;
 8 | 
 9 | class EventException extends ErrorException
10 | {
11 |     // Empty
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Event/EventProducer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Event;
 4 | 
 5 | use Bow\Event\Contracts\EventListener;
 6 | use Bow\Event\Contracts\EventShouldQueue;
 7 | use Bow\Queue\ProducerService;
 8 | 
 9 | class EventProducer extends ProducerService
10 | {
11 |     /**
12 |      * EventProducer constructor
13 |      *
14 |      * @param EventListener|EventShouldQueue $event
15 |      * @param mixed                          $payload
16 |      */
17 |     public function __construct(
18 |         private readonly mixed $event,
19 |         private readonly mixed $payload = null,
20 |     ) {
21 |         parent::__construct();
22 |     }
23 | 
24 |     /**
25 |      * Process event
26 |      *
27 |      * @return void
28 |      */
29 |     public function process(): void
30 |     {
31 |         $this->event->process($this->payload);
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/Event/README.md:
--------------------------------------------------------------------------------
 1 | # Bow Event
 2 | 
 3 | Bow Framework's event driver system is very simple event subscription and interpage page event:
 4 | 
 5 | Let's show a little exemple:
 6 | 
 7 | ```php
 8 | use Bow\Event\Event;
 9 | 
10 | // Add listener on send.mail event
11 | Event::on("email.sent", function (array $payload) {
12 |     $name = $payload["name"];
13 |     echo "An email was sent to $name";
14 | });
15 | 
16 | // Emit the send.mail event
17 | Event::emit("email.sent", ["name" => "Franck DAKIA"]);
18 | ```
19 | 
20 | NB: Is recommanded to write all event listener into simple class and define the event to the app Kernel file in boot
21 | method.
22 | 
23 | ```php
24 | use App\Models\Activity;
25 | 
26 | use Bow\Event\EventListener;
27 | 
28 | class ActivityEvent extends EventListener
29 | {
30 |     /**
31 |      * Listener method
32 |      * 
33 |      * @param array payload
34 |      * @return mixed
35 |      */
36 |     public function process($payload)
37 |     {
38 |         Activity::create($payload);
39 |     }
40 | }
41 | ```
42 | 
43 | Into Kernel file
44 | 
45 | ```php
46 | public function events()
47 | {
48 |     return [
49 |         "user.activity" => [
50 |             ActivityEvent::class
51 |         ]
52 |     ]
53 | }
54 | ```
55 | 


--------------------------------------------------------------------------------
/src/Http/Client/HttpClientException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Http\Client;
 6 | 
 7 | use Exception;
 8 | 
 9 | class HttpClientException extends Exception
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Http/Exception/BadRequestException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Http\Exception;
 6 | 
 7 | class BadRequestException extends HttpException
 8 | {
 9 |     /**
10 |      * BadRequestException constructor
11 |      *
12 |      * @param string $message
13 |      * @param string $status
14 |      */
15 |     public function __construct(string $message, $status = 'BAD_REQUEST')
16 |     {
17 |         parent::__construct($message, 400);
18 | 
19 |         $this->status = $status;
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Http/Exception/CreatedException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Http\Exception;
 6 | 
 7 | class CreatedException extends HttpException
 8 | {
 9 |     /**
10 |      * CreatedException constructor
11 |      *
12 |      * @param string $message
13 |      * @param string $status
14 |      */
15 |     public function __construct(string $message, $status = 'CONTENT_CREATED')
16 |     {
17 |         parent::__construct($message, 201);
18 | 
19 |         $this->status = $status;
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Http/Exception/ForbiddenException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Http\Exception;
 6 | 
 7 | class ForbiddenException extends HttpException
 8 | {
 9 |     /**
10 |      * ForbiddenException constructor
11 |      *
12 |      * @param string $message
13 |      * @param string $status
14 |      */
15 |     public function __construct(string $message, $status = 'FORBIDDEN')
16 |     {
17 |         parent::__construct($message, 403);
18 | 
19 |         $this->status = $status;
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Http/Exception/HttpException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Http\Exception;
 6 | 
 7 | use Exception;
 8 | 
 9 | class HttpException extends Exception
10 | {
11 |     /**
12 |      * Define the status code has message
13 |      *
14 |      * @var string
15 |      */
16 |     protected $status = 'OK';
17 | 
18 |     /**
19 |      * Define the errors bags
20 |      *
21 |      * @var array
22 |      */
23 |     protected array $error_bags = [];
24 | 
25 |     /**
26 |      * HttpException constructor
27 |      *
28 |      * @param string $message
29 |      * @param int    $code
30 |      */
31 |     public function __construct(string $message, int $code = 200)
32 |     {
33 |         response()->status($code);
34 | 
35 |         parent::__construct($message, $code);
36 |     }
37 | 
38 |     /**
39 |      * Get the define user error code
40 |      *
41 |      * @return string
42 |      */
43 |     public function getStatus(): string
44 |     {
45 |         return $this->status;
46 |     }
47 | 
48 |     /**
49 |      * Get the status code
50 |      *
51 |      * @return int
52 |      */
53 |     public function getStatusCode(): int
54 |     {
55 |         return $this->getCode();
56 |     }
57 | 
58 |     /**
59 |      * Get the errors bags
60 |      *
61 |      * @return array
62 |      */
63 |     public function getErrorBags(): array
64 |     {
65 |         return $this->error_bags;
66 |     }
67 | 
68 |     /**
69 |      * Set the errors bags
70 |      *
71 |      * @param array $errors
72 |      */
73 |     public function setErrorBags(array $errors)
74 |     {
75 |         $this->error_bags = $errors;
76 |     }
77 | }
78 | 


--------------------------------------------------------------------------------
/src/Http/Exception/InternalServerErrorException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Http\Exception;
 6 | 
 7 | class InternalServerErrorException extends HttpException
 8 | {
 9 |     /**
10 |      * InternalServerErrorException constructor
11 |      *
12 |      * @param string $message
13 |      * @param string $status
14 |      */
15 |     public function __construct(string $message, $status = 'INTERNAL_SERVER_ERROR')
16 |     {
17 |         parent::__construct($message, 500);
18 | 
19 |         $this->status = $status;
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Http/Exception/MethodNotAllowedException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Http\Exception;
 6 | 
 7 | class MethodNotAllowedException extends HttpException
 8 | {
 9 |     /**
10 |      * MethodNotAllowedException constructor
11 |      *
12 |      * @param string $message
13 |      * @param string $status
14 |      */
15 |     public function __construct(string $message, $status = 'METHOD_NOT_ALLOWED')
16 |     {
17 |         parent::__construct($message, 405);
18 | 
19 |         $this->status = $status;
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Http/Exception/NoContentException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Http\Exception;
 6 | 
 7 | class NoContentException extends HttpException
 8 | {
 9 |     /**
10 |      * NoContentException constructor
11 |      *
12 |      * @param string $message
13 |      * @param string $status
14 |      */
15 |     public function __construct(string $message, $status = 'NO_CONTENT')
16 |     {
17 |         parent::__construct($message, 204);
18 | 
19 |         $this->status = $status;
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Http/Exception/NotFoundException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Http\Exception;
 6 | 
 7 | class NotFoundException extends HttpException
 8 | {
 9 |     /**
10 |      * NotFoundException constructor
11 |      *
12 |      * @param string $message
13 |      * @param string $status
14 |      */
15 |     public function __construct(string $message, $status = 'NOT_FOUND')
16 |     {
17 |         parent::__construct($message, 404);
18 | 
19 |         $this->status = $status;
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Http/Exception/RequestException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Http\Exception;
 6 | 
 7 | class RequestException extends HttpException
 8 | {
 9 |     /**
10 |      * Define the http response code
11 |      *
12 |      * @var int
13 |      */
14 |     protected $code;
15 | 
16 |     /**
17 |      * Set the http code
18 |      *
19 |      * @param  int $code
20 |      * @return void
21 |      */
22 |     public function setCode(int $code)
23 |     {
24 |         $this->code = $code;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Http/Exception/ResponseException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Http\Exception;
 6 | 
 7 | class ResponseException extends HttpException
 8 | {
 9 |     /**
10 |      * Define the http response code
11 |      *
12 |      * @var int
13 |      */
14 |     protected $code;
15 | 
16 |     /**
17 |      * Set the http code
18 |      *
19 |      * @param  int $code
20 |      * @return void
21 |      */
22 |     public function setCode(int $code)
23 |     {
24 |         $this->code = $code;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Http/Exception/ServerAccessControlException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Http\Exception;
 6 | 
 7 | use ErrorException;
 8 | 
 9 | class ServerAccessControlException extends ErrorException
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Http/Exception/UnauthorizedException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Http\Exception;
 6 | 
 7 | class UnauthorizedException extends HttpException
 8 | {
 9 |     /**
10 |      * UnauthorizedException constructor
11 |      *
12 |      * @param string $message
13 |      * @param string $status
14 |      */
15 |     public function __construct(string $message, $status = 'UNAUTHORIZED')
16 |     {
17 |         parent::__construct($message, 401);
18 | 
19 |         $this->status = $status;
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Http/Exception/UploadedFileException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Http\Exception;
 6 | 
 7 | use ErrorException;
 8 | 
 9 | class UploadedFileException extends ErrorException
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Http/README.md:
--------------------------------------------------------------------------------
 1 | # Bow HTTP
 2 | 
 3 | Bow Framework's http system is provider all you need to provider HTTP response.
 4 | 
 5 | - Custom header
 6 | - Automatique response type detection
 7 | - File downloading
 8 | - etc.
 9 | 
10 | Let's show a little exemple:
11 | 
12 | ```php
13 | use Bow\Http\Request;
14 | 
15 | $app->post('/', function (Request $request) {
16 |     $name = $request->get('name');
17 |     response()->addHeader("X-Custom-Header", "Bow Framework");
18 |     return response()->json(["data" => "Hello $name!"]);
19 | });
20 | ```
21 | 
22 | Is very enjoyful api
23 | 


--------------------------------------------------------------------------------
/src/Mail/Adapters/LogAdapter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Mail\Adapters;
 6 | 
 7 | use Bow\Mail\Contracts\MailAdapterInterface;
 8 | use Bow\Mail\Envelop;
 9 | use Bow\Support\Str;
10 | 
11 | class LogAdapter implements MailAdapterInterface
12 | {
13 |     /**
14 |      * The configuration
15 |      *
16 |      * @var array
17 |      */
18 |     private array $config;
19 | 
20 |     /**
21 |      * The log path
22 |      *
23 |      * @var string
24 |      */
25 |     private string $path;
26 | 
27 |     /**
28 |      * LogAdapter Constructor
29 |      *
30 |      * @param array $config
31 |      */
32 |     public function __construct(array $config = [])
33 |     {
34 |         $this->config = $config;
35 |         $this->path = $config['path'];
36 | 
37 |         if (!is_dir($this->path)) {
38 |             mkdir($this->path, 0755, true);
39 |         }
40 |     }
41 | 
42 |     /**
43 |      * Implement send email
44 |      *
45 |      * @param  Envelop $envelop
46 |      * @return bool
47 |      */
48 |     public function send(Envelop $envelop): bool
49 |     {
50 |         $filename = date('Y-m-d_H-i-s') . '_' . Str::random(6) . '.eml';
51 |         $filepath = $this->path . '/' . $filename;
52 | 
53 |         $content = "Date: " . date('r') . "\n";
54 |         $content .= $envelop->compileHeaders();
55 | 
56 |         $content .= "To: " . implode(
57 |             ', ',
58 |             array_map(
59 |                 function ($to) {
60 |                     return $to[0] ? "{$to[0]} <{$to[1]}>" : $to[1];
61 |                 },
62 |                 $envelop->getTo()
63 |             )
64 |         ) . "\n";
65 | 
66 |         $content .= "Subject: " . $envelop->getSubject() . "\n";
67 |         $content .= $envelop->getMessage();
68 | 
69 |         return (bool)file_put_contents($filepath, $content);
70 |     }
71 | }
72 | 


--------------------------------------------------------------------------------
/src/Mail/Contracts/MailAdapterInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Mail\Contracts;
 6 | 
 7 | use Bow\Mail\Envelop;
 8 | 
 9 | interface MailAdapterInterface
10 | {
11 |     /**
12 |      * Send mail by any driver
13 |      *
14 |      * @param  Envelop $envelop
15 |      * @return bool
16 |      */
17 |     public function send(Envelop $envelop): bool;
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Mail/Exception/MailException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Mail\Exception;
 6 | 
 7 | use ErrorException;
 8 | 
 9 | class MailException extends ErrorException
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Mail/Exception/SmtpException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Mail\Exception;
 6 | 
 7 | use ErrorException;
 8 | 
 9 | class SmtpException extends ErrorException
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Mail/Exception/SocketException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Mail\Exception;
 6 | 
 7 | use Exception;
 8 | 
 9 | class SocketException extends Exception
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Mail/MailConfiguration.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Mail;
 6 | 
 7 | use Bow\Configuration\Configuration;
 8 | use Bow\Configuration\Loader;
 9 | 
10 | class MailConfiguration extends Configuration
11 | {
12 |     /**
13 |      * @inheritdoc
14 |      */
15 |     public function create(Loader $config): void
16 |     {
17 |         $this->container->bind(
18 |             'mail',
19 |             function () use ($config) {
20 |                 return Mail::configure($config['mail']);
21 |             }
22 |         );
23 |     }
24 | 
25 |     /**
26 |      * @inheritdoc
27 |      */
28 |     public function run(): void
29 |     {
30 |         $this->container->make('mail');
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Mail/MailQueueProducer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Mail;
 4 | 
 5 | use Bow\Queue\ProducerService;
 6 | use Bow\View\View;
 7 | use Throwable;
 8 | 
 9 | class MailQueueProducer extends ProducerService
10 | {
11 |     /**
12 |      * The message bag
13 |      *
14 |      * @var array
15 |      */
16 |     private array $bags = [];
17 | 
18 |     /**
19 |      * MailQueueProducer constructor
20 |      *
21 |      * @param string  $view
22 |      * @param array   $data
23 |      * @param Envelop $message
24 |      */
25 |     public function __construct(
26 |         string $view,
27 |         array $data,
28 |         Envelop $envelop
29 |     ) {
30 |         parent::__construct();
31 | 
32 |         $this->bags = [
33 |             "view" => $view,
34 |             "data" => $data,
35 |             "envelop" => $envelop,
36 |         ];
37 |     }
38 | 
39 |     /**
40 |      * Process mail
41 |      *
42 |      * @return void
43 |      */
44 |     public function process(): void
45 |     {
46 |         $envelop = $this->bags["envelop"];
47 | 
48 |         $envelop->setMessage(
49 |             View::parse($this->bags["view"], $this->bags["data"])->getContent()
50 |         );
51 | 
52 |         Mail::getInstance()->send($envelop);
53 |     }
54 | 
55 |     /**
56 |      * Send the processing exception
57 |      *
58 |      * @param  Throwable $e
59 |      * @return void
60 |      */
61 |     public function onException(Throwable $e): void
62 |     {
63 |         $this->deleteJob();
64 |     }
65 | }
66 | 


--------------------------------------------------------------------------------
/src/Mail/README.md:
--------------------------------------------------------------------------------
 1 | # Bow Mail
 2 | 
 3 | Bow Framework's mail system is very simple email delivery system with support:
 4 | 
 5 | - Native PHP mail api
 6 | - SMTP setting
 7 | - SES (Simple Email System)
 8 | - With extended driver interface
 9 | 
10 | Let's show a little exemple:
11 | 
12 | ```php
13 | use Bow\Mail\Envelop;
14 | 
15 | email('view.template', function (Message $message) {
16 |     $message->to("papac@bowphp.com");
17 |     $message->subject("Hello Franck DAKIA");
18 | });
19 | ```
20 | 
21 | Is very enjoyful api
22 | 


--------------------------------------------------------------------------------
/src/Messaging/Adapters/DatabaseChannelAdapter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Messaging\Adapters;
 4 | 
 5 | use Bow\Database\Barry\Model;
 6 | use Bow\Database\Database;
 7 | use Bow\Messaging\Contracts\ChannelAdapterInterface;
 8 | use Bow\Messaging\Messaging;
 9 | 
10 | class DatabaseChannelAdapter implements ChannelAdapterInterface
11 | {
12 |     /**
13 |      * Send the notification to database
14 |      *
15 |      * @param Model     $context
16 |      * @param Messaging $message
17 |      */
18 |     public function send(Model $context, Messaging $message): void
19 |     {
20 |         if (!method_exists($message, 'toDatabase')) {
21 |             return;
22 |         }
23 | 
24 |         $database = $message->toDatabase($context);
25 | 
26 |         Database::table(config('messaging.notification.table') ?? 'notifications')->insert(
27 |             [
28 |             'id' => str_uuid(),
29 |             'data' => $database['data'],
30 |             'concern_id' => $context->getKey(),
31 |             'concern_type' => get_class($context),
32 |             'type' => $database['type'] ?? 'notification',
33 |             ]
34 |         );
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/Messaging/Adapters/MailChannelAdapter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Messaging\Adapters;
 4 | 
 5 | use Bow\Database\Barry\Model;
 6 | use Bow\Mail\Mail;
 7 | use Bow\Messaging\Contracts\ChannelAdapterInterface;
 8 | use Bow\Messaging\Messaging;
 9 | 
10 | class MailChannelAdapter implements ChannelAdapterInterface
11 | {
12 |     /**
13 |      * Send the notification to mail
14 |      *
15 |      * @param  Model     $context
16 |      * @param  Messaging $message
17 |      * @return void
18 |      */
19 |     public function send(Model $context, Messaging $message): void
20 |     {
21 |         if (!method_exists($message, 'toMail')) {
22 |             return;
23 |         }
24 | 
25 |         $envelop = $message->toMail($context);
26 | 
27 |         Mail::getInstance()->send($envelop);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Messaging/Adapters/SlackChannelAdapter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Messaging\Adapters;
 4 | 
 5 | use Bow\Database\Barry\Model;
 6 | use Bow\Messaging\Contracts\ChannelAdapterInterface;
 7 | use Bow\Messaging\Messaging;
 8 | use GuzzleHttp\Client;
 9 | use GuzzleHttp\Exception\GuzzleException;
10 | 
11 | class SlackChannelAdapter implements ChannelAdapterInterface
12 | {
13 |     /**
14 |      * Send message via Slack
15 |      *
16 |      * @param  Model     $context
17 |      * @param  Messaging $message
18 |      * @return void
19 |      * @throws GuzzleException
20 |      */
21 |     public function send(Model $context, Messaging $message): void
22 |     {
23 |         if (!method_exists($message, 'toSlack')) {
24 |             return;
25 |         }
26 | 
27 |         $data = $message->toSlack($context);
28 | 
29 |         if (!isset($data['content'])) {
30 |             throw new \InvalidArgumentException('The content are required for Slack');
31 |         }
32 | 
33 |         $webhook_url = $data['webhook_url'] ?? config('messaging.slack.webhook_url');
34 | 
35 |         if (empty($webhook_url)) {
36 |             throw new \InvalidArgumentException('The webhook URL is required for Slack');
37 |         }
38 | 
39 |         $client = new Client();
40 | 
41 |         try {
42 |             $client->post(
43 |                 $webhook_url,
44 |                 [
45 |                 'json' => $data['content'],
46 |                 'headers' => [
47 |                     'Content-Type' => 'application/json'
48 |                 ]
49 |                 ]
50 |             );
51 |         } catch (\Exception $e) {
52 |             throw new \RuntimeException('Error while sending Slack message: ' . $e->getMessage());
53 |         }
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/src/Messaging/Contracts/ChannelAdapterInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Messaging\Contracts;
 4 | 
 5 | use Bow\Database\Barry\Model;
 6 | use Bow\Messaging\Messaging;
 7 | 
 8 | interface ChannelAdapterInterface
 9 | {
10 |     /**
11 |      * Send a message through the channel
12 |      *
13 |      * @param  Model     $context
14 |      * @param  Messaging $message
15 |      * @return void
16 |      */
17 |     public function send(Model $context, Messaging $message): void;
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Messaging/MessagingQueueProducer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Messaging;
 4 | 
 5 | use Bow\Database\Barry\Model;
 6 | use Bow\Queue\ProducerService;
 7 | use Throwable;
 8 | 
 9 | class MessagingQueueProducer extends ProducerService
10 | {
11 |     /**
12 |      * The message bag
13 |      *
14 |      * @var array
15 |      */
16 |     private array $bags = [];
17 | 
18 |     /**
19 |      * MessagingQueueProducer constructor
20 |      *
21 |      * @param Model     $context
22 |      * @param Messaging $message
23 |      */
24 |     public function __construct(
25 |         Model $context,
26 |         Messaging $message,
27 |     ) {
28 |         parent::__construct();
29 | 
30 |         $this->bags = [
31 |             "message" => $message,
32 |             "context" => $context,
33 |         ];
34 |     }
35 | 
36 |     /**
37 |      * Process mail
38 |      *
39 |      * @return void
40 |      */
41 |     public function process(): void
42 |     {
43 |         $message = $this->bags['message'];
44 |         $message->process($this->bags['context']);
45 |     }
46 | 
47 |     /**
48 |      * Send the processing exception
49 |      *
50 |      * @param  Throwable $e
51 |      * @return void
52 |      */
53 |     public function onException(Throwable $e): void
54 |     {
55 |         $this->deleteJob();
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/src/Middleware/AuthMiddleware.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Middleware;
 6 | 
 7 | use Bow\Auth\Auth;
 8 | use Bow\Http\Redirect;
 9 | use Bow\Http\Request;
10 | 
11 | class AuthMiddleware implements BaseMiddleware
12 | {
13 |     /**
14 |      * Handle an incoming request.
15 |      *
16 |      * @param  Request  $request
17 |      * @param  callable $next
18 |      * @param  array    $args
19 |      * @return Redirect
20 |      */
21 |     public function process(Request $request, callable $next, array $args = []): mixed
22 |     {
23 |         if (Auth::getInstance()->check()) {
24 |             return $next($request);
25 |         }
26 | 
27 |         return redirect($this->redirectTo());
28 |     }
29 | 
30 |     /**
31 |      * Redirect to
32 |      *
33 |      * @return string
34 |      */
35 |     public function redirectTo(): string
36 |     {
37 |         return '/';
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Middleware/BaseMiddleware.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Middleware;
 6 | 
 7 | use Bow\Http\Request;
 8 | 
 9 | interface BaseMiddleware
10 | {
11 |     /**
12 |      * The handle method
13 |      *
14 |      * @param  Request  $request
15 |      * @param  callable $next
16 |      * @param  array    $args
17 |      * @return mixed
18 |      */
19 |     public function process(Request $request, callable $next, array $args = []): mixed;
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Middleware/CsrfMiddleware.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Middleware;
 6 | 
 7 | use Bow\Http\Request;
 8 | use Bow\Security\Exception\TokenMismatch;
 9 | 
10 | class CsrfMiddleware implements BaseMiddleware
11 | {
12 |     /**
13 |      * Handle an incoming request.
14 |      *
15 |      * @param  Request  $request
16 |      * @param  callable $next
17 |      * @param  array    $args
18 |      * @throws
19 |      */
20 |     public function process(Request $request, callable $next, array $args = []): mixed
21 |     {
22 |         foreach ($this->preventOn() as $url) {
23 |             if ($request->is($url)) {
24 |                 return $next($request);
25 |             }
26 |         }
27 | 
28 |         if ($request->isAjax()) {
29 |             if ($request->getHeader('x-csrf-token') === session('_token')) {
30 |                 return $next($request);
31 |             }
32 | 
33 |             response()->status(401);
34 | 
35 |             throw new TokenMismatch(
36 |                 'The request csrf token mismatch'
37 |             );
38 |         }
39 | 
40 |         if ($request->get('_token') == $request->session()->get('_token')) {
41 |             return $next($request);
42 |         }
43 | 
44 |         throw new TokenMismatch(
45 |             'The request csrf token mismatch'
46 |         );
47 |     }
48 | 
49 |     /**
50 |      * Prevent csrf action on urls
51 |      *
52 |      * @return array
53 |      */
54 |     public function preventOn(): array
55 |     {
56 |         return [
57 | 
58 |         ];
59 |     }
60 | }
61 | 


--------------------------------------------------------------------------------
/src/Queue/Adapters/SyncAdapter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Queue\Adapters;
 6 | 
 7 | use Bow\Queue\ProducerService;
 8 | 
 9 | class SyncAdapter extends QueueAdapter
10 | {
11 |     /**
12 |      * Define the config
13 |      *
14 |      * @var array
15 |      */
16 |     private array $config;
17 | 
18 |     /**
19 |      * Configure SyncAdapter driver
20 |      *
21 |      * @param  array $config
22 |      * @return mixed
23 |      */
24 |     public function configure(array $config): SyncAdapter
25 |     {
26 |         $this->config = $config;
27 | 
28 |         return $this;
29 |     }
30 | 
31 |     /**
32 |      * Queue a job
33 |      *
34 |      * @param  ProducerService $producer
35 |      * @return void
36 |      */
37 |     public function push(ProducerService $producer): void
38 |     {
39 |         $producer->process();
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/Queue/QueueConfiguration.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Queue;
 6 | 
 7 | use Bow\Configuration\Configuration;
 8 | use Bow\Configuration\Loader;
 9 | use Bow\Queue\Connection as QueueConnection;
10 | 
11 | class QueueConfiguration extends Configuration
12 | {
13 |     /**
14 |      * @inheritdoc
15 |      */
16 |     public function create(Loader $config): void
17 |     {
18 |         $this->container->bind(
19 |             'queue',
20 |             function () use ($config) {
21 |                 return new QueueConnection($config["worker"] ?? $config["queue"]);
22 |             }
23 |         );
24 |     }
25 | 
26 |     /**
27 |      * @inheritdoc
28 |      */
29 |     public function run(): void
30 |     {
31 |         $this->container->make('queue');
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/Queue/README.md:
--------------------------------------------------------------------------------
 1 | # Bow Queue
 2 | 
 3 | Bow Framework's queue system help you to make a simple and powerful queue/job (consumer/producer) for your process whish
 4 | take a low of time.
 5 | 
 6 | ```php
 7 | use App\Producers\EmailProducer;
 8 | 
 9 | queue(new EmailProducer($email));
10 | ```
11 | 
12 | Launch the worker/consumer.
13 | 
14 | ```bash
15 | php bow run:worker --retry=3 --queue=mailing
16 | ```
17 | 


--------------------------------------------------------------------------------
/src/Queue/WorkerService.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Queue;
 6 | 
 7 | use Bow\Queue\Adapters\QueueAdapter;
 8 | 
 9 | class WorkerService
10 | {
11 |     /**
12 |      * Determine the instance of QueueAdapter
13 |      *
14 |      * @var QueueAdapter
15 |      */
16 |     private QueueAdapter $connection;
17 | 
18 |     /**
19 |      * Make connection base on default name
20 |      *
21 |      * @param  QueueAdapter $connection
22 |      * @return void
23 |      */
24 |     public function setConnection(QueueAdapter $connection): void
25 |     {
26 |         $this->connection = $connection;
27 |     }
28 | 
29 |     /**
30 |      * Start the consumer
31 |      *
32 |      * @param  string $queue
33 |      * @param  int    $tries
34 |      * @param  int    $sleep
35 |      * @param  int    $timeout
36 |      * @param  int    $memory
37 |      * @return void
38 |      */
39 |     public function run(
40 |         string $queue = "default",
41 |         int $tries = 3,
42 |         int $sleep = 5,
43 |         int $timeout = 60,
44 |         int $memory = 128
45 |     ): void {
46 |         $this->connection->setQueue($queue);
47 |         $this->connection->setTries($tries);
48 |         $this->connection->setSleep($sleep);
49 |         $this->connection->work($timeout, $memory);
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/src/Router/Exception/RouterException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Router\Exception;
 6 | 
 7 | use Bow\Http\Exception\HttpException;
 8 | 
 9 | class RouterException extends HttpException
10 | {
11 |     /**
12 |      * RouterException constructor
13 |      *
14 |      * @param string $message
15 |      * @param string $status
16 |      */
17 |     public function __construct(string $message, $status = 'NOT_FOUND')
18 |     {
19 |         parent::__construct($message, 404);
20 | 
21 |         $this->status = $status;
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Router/README.md:
--------------------------------------------------------------------------------
 1 | # Bow Router
 2 | 
 3 | Bow Framework's routing system is very simple with:
 4 | 
 5 | - Route naming support
 6 | - Route prefix support
 7 | - Route parameter catcher support
 8 | 
 9 | Let's show a little exemple:
10 | 
11 | ```php
12 | $app->get('/', function () {
13 |     return "Hello guy!";
14 | });
15 | ```
16 | 
17 | ## Diagramme de flux du routage
18 | 
19 | ```mermaid
20 | sequenceDiagram
21 |     participant Client as Client HTTP
22 |     participant Router as Router
23 |     participant Route as Route
24 |     participant Middleware as Middleware
25 |     participant Controller as Controller/Callback
26 |     participant Response as Response
27 | 
28 |     Note over Client,Response: Traitement d'une requête HTTP
29 |     
30 |     Client->>Router: Requête HTTP (GET /users)
31 |     
32 |     Router->>Router: match(uri)
33 |     
34 |     alt Route trouvée
35 |         Router->>Route: match(uri)
36 |         Route->>Route: checkRequestUri()
37 |         
38 |         alt Avec Middleware
39 |             Route->>Middleware: process(request)
40 |             Middleware-->>Route: next(request)
41 |         end
42 |         
43 |         Route->>Route: getParameters()
44 |         Route->>Controller: call(parameters)
45 |         Controller-->>Response: return response
46 |         Response-->>Client: Envoie réponse HTTP
47 |     else Route non trouvée
48 |         Router-->>Response: 404 Not Found
49 |         Response-->>Client: Erreur 404
50 |     end
51 | 
52 |     Note over Client,Response: Exemple de définition de route
53 |     
54 |     Note right of Router: $app->get('/users/:id', function($id) { ... })
55 |     Note right of Router: $app->post('/users', [UserController::class, 'store'])
56 | ```
57 | 
58 | Is very joyful api
59 | 


--------------------------------------------------------------------------------
/src/Security/Crypto.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Security;
 6 | 
 7 | use Bow\Support\Str;
 8 | 
 9 | class Crypto
10 | {
11 |     /**
12 |      * The security key
13 |      *
14 |      * @var ?string
15 |      */
16 |     private static ?string $key = null;
17 | 
18 |     /**
19 |      * The security cipher
20 |      *
21 |      * @var string
22 |      */
23 |     private static string $cipher = 'AES-256-CBC';
24 | 
25 |     /**
26 |      * Set the key
27 |      *
28 |      * @param string      $key
29 |      * @param string|null $cipher
30 |      */
31 |     public static function setKey(string $key, ?string $cipher = null): void
32 |     {
33 |         static::$key = $key;
34 | 
35 |         if (!is_null($cipher)) {
36 |             static::$cipher = $cipher;
37 |         }
38 |     }
39 | 
40 |     /**
41 |      * Encrypt data
42 |      *
43 |      * @param  string $data
44 |      * @return string|bool
45 |      */
46 |     public static function encrypt(string $data): string|bool
47 |     {
48 |         $iv_size = openssl_cipher_iv_length(static::$cipher);
49 | 
50 |         $iv = Str::slice(sha1(static::$key), 0, $iv_size);
51 | 
52 |         return openssl_encrypt($data, static::$cipher, static::$key, 0, $iv);
53 |     }
54 | 
55 |     /**
56 |      * decrypt
57 |      *
58 |      * @param string $data
59 |      *
60 |      * @return string|bool
61 |      */
62 |     public static function decrypt(string $data): string|bool
63 |     {
64 |         $iv_size = openssl_cipher_iv_length(static::$cipher);
65 | 
66 |         $iv = Str::slice(sha1(static::$key), 0, $iv_size);
67 | 
68 |         return openssl_decrypt($data, static::$cipher, static::$key, 0, $iv);
69 |     }
70 | }
71 | 


--------------------------------------------------------------------------------
/src/Security/CryptoConfiguration.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Security;
 6 | 
 7 | use Bow\Configuration\Configuration;
 8 | use Bow\Configuration\Loader;
 9 | 
10 | class CryptoConfiguration extends Configuration
11 | {
12 |     /**
13 |      * @inheritdoc
14 |      */
15 |     public function create(Loader $config): void
16 |     {
17 |         $this->container->bind(
18 |             'security',
19 |             function () use ($config) {
20 |                 Crypto::setkey($config['security.key'], $config['security.cipher']);
21 | 
22 |                 return Crypto::class;
23 |             }
24 |         );
25 |     }
26 | 
27 |     /**
28 |      * @inheritdoc
29 |      */
30 |     public function run(): void
31 |     {
32 |         $this->container->make('security');
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Security/Exception/TokenMismatch.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Security\Exception;
 6 | 
 7 | use Bow\Http\Exception\HttpException;
 8 | 
 9 | class TokenMismatch extends HttpException
10 | {
11 |     /**
12 |      * TokenMismatch constructor
13 |      *
14 |      * @param string $message
15 |      * @param string $status
16 |      */
17 |     public function __construct(string $message, $status = 'TOKEN_NOT_VALID')
18 |     {
19 |         parent::__construct($message, 401);
20 | 
21 |         $this->status = $status;
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Security/README.md:
--------------------------------------------------------------------------------
 1 | # Bow Security
 2 | 
 3 | Bow Framework's security system protect you to CSRF, XSS and add the powerful data encryption system where you can
 4 | change easily the encryption algorithm.
 5 | 
 6 | Create the new hash. Usualy, it's use for make user password
 7 | 
 8 | ```php
 9 | Hash::make("hash content");
10 | ```
11 | 
12 | Encrypt data
13 | 
14 | ```php
15 | $encoded = encrypt("value");
16 | // out it's the encrypted value
17 | ```
18 | 


--------------------------------------------------------------------------------
/src/Session/Adapters/DurationTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Session\Adapters;
 6 | 
 7 | trait DurationTrait
 8 | {
 9 |     /**
10 |      * Create the timestamp
11 |      *
12 |      * @param  int|null $max_lifetime
13 |      * @return string
14 |      */
15 |     private function createTimestamp(?int $max_lifetime = null): string
16 |     {
17 |         $lifetime = !is_null($max_lifetime) ? $max_lifetime : (config('session.lifetime') * 60);
18 | 
19 |         return date('Y-m-d H:i:s', time() + (int)$lifetime);
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Session/Exception/SessionException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Session\Exception;
 6 | 
 7 | use Exception;
 8 | 
 9 | class SessionException extends Exception
10 | {
11 |     // Empty
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Session/README.md:
--------------------------------------------------------------------------------
 1 | # Bow Session
 2 | 
 3 | Bow Framework's session system is beautiful interface to manage PHP Session feature and Custom session.
 4 | He support:
 5 | 
 6 | - Native PHP Session
 7 | - Database session driver
 8 | 
 9 | ```php
10 | // Get the content of name key
11 | session("name");
12 | ```
13 | 
14 | We can set value with key `name`.
15 | 
16 | ```php
17 | session(["name", "value"]);
18 | ```
19 | 
20 | # Bow Cookie
21 | 
22 | Get the cookie content:
23 | 
24 | ```php
25 | cookie('name');
26 | ```
27 | 
28 | Set the cookie:
29 | 
30 | ```php
31 | cookie('name', 'value');
32 | ```
33 | 
34 | NB: You can add your custom session support like redis or mongodb
35 | 


--------------------------------------------------------------------------------
/src/Session/SessionConfiguration.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Session;
 6 | 
 7 | use Bow\Configuration\Configuration;
 8 | use Bow\Configuration\Loader;
 9 | use Bow\Security\Tokenize;
10 | 
11 | class SessionConfiguration extends Configuration
12 | {
13 |     /**
14 |      * @inheritdoc
15 |      */
16 |     public function create(Loader $config): void
17 |     {
18 |         $this->container->bind(
19 |             'session',
20 |             function () use ($config) {
21 |                 $session = Session::configure((array)$config['session']);
22 | 
23 |                 Tokenize::makeCsrfToken((int)$config['session.lifetime']);
24 | 
25 |                 // Reboot the old request values
26 |                 Session::getInstance()->add('__bow.old', []);
27 | 
28 |                 return $session;
29 |             }
30 |         );
31 |     }
32 | 
33 |     /**
34 |      * @inheritdoc
35 |      */
36 |     public function run(): void
37 |     {
38 |         $this->container->make('session');
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Storage/Contracts/ServiceInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Storage\Contracts;
 6 | 
 7 | interface ServiceInterface extends FilesystemInterface
 8 | {
 9 |     /**
10 |      * Configure service
11 |      *
12 |      * @param array $config
13 |      */
14 |     public static function configure(array $config): FilesystemInterface;
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Storage/Exception/DiskNotFoundException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Storage\Exception;
 6 | 
 7 | use ErrorException;
 8 | 
 9 | class DiskNotFoundException extends ErrorException
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Storage/Exception/ResourceException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Storage\Exception;
 6 | 
 7 | use ErrorException;
 8 | 
 9 | class ResourceException extends ErrorException
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Storage/Exception/ServiceConfigurationNotFoundException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Storage\Exception;
 6 | 
 7 | class ServiceConfigurationNotFoundException extends ServiceNotFoundException
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/Storage/Exception/ServiceNotFoundException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Storage\Exception;
 6 | 
 7 | use ErrorException;
 8 | 
 9 | class ServiceNotFoundException extends ErrorException
10 | {
11 |     /**
12 |      * The service name
13 |      *
14 |      * @var string
15 |      */
16 |     private $service_name;
17 | 
18 |     /**
19 |      * Set the service name
20 |      *
21 |      * @param  string $service_name
22 |      * @return ServiceNotFoundException
23 |      */
24 |     public function setService(string $service_name): ServiceNotFoundException
25 |     {
26 |         $this->service_name = $service_name;
27 | 
28 |         return $this;
29 |     }
30 | 
31 |     /**
32 |      * Get the service name
33 |      *
34 |      * @return string
35 |      */
36 |     public function getService()
37 |     {
38 |         return $this->service_name;
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Storage/README.md:
--------------------------------------------------------------------------------
 1 | # Bow Storage
 2 | 
 3 | Bow Framework's storage system is beautiful interface to manage file access. He support:
 4 | 
 5 | - File System
 6 | - FTP
 7 | - Simple Storage System (S3)
 8 | 
 9 | ```php
10 | // Get the content of code.js file
11 | mount("public")->get("code.js");
12 | ```
13 | 
14 | Load some service for work on.
15 | 
16 | ```php
17 | // Get the content of code.js file
18 | ftp()->get("code.js");
19 | ```
20 | 


--------------------------------------------------------------------------------
/src/Storage/StorageConfiguration.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Storage;
 6 | 
 7 | use Bow\Configuration\Configuration;
 8 | use Bow\Configuration\Loader;
 9 | 
10 | class StorageConfiguration extends Configuration
11 | {
12 |     /**
13 |      * @inheritdoc
14 |      */
15 |     public function create(Loader $config): void
16 |     {
17 |         $this->container->bind(
18 |             'storage',
19 |             function () use ($config) {
20 |                 return Storage::configure($config['storage']);
21 |             }
22 |         );
23 |     }
24 | 
25 |     /**
26 |      * @inheritdoc
27 |      */
28 |     public function run(): void
29 |     {
30 |         $this->container->make('storage');
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Support/Log.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Support;
 4 | 
 5 | /**
 6 |  * @method static void error(string $message, array $context = [])
 7 |  * @method static void info(string $message, array $context = [])
 8 |  * @method static void warning(string $message, array $context = [])
 9 |  * @method static void alert(string $message, array $context = [])
10 |  * @method static void critical(string $message, array $context = [])
11 |  * @method static void emergency(string $message, array $context = [])
12 |  */
13 | class Log
14 | {
15 |     /**
16 |      * Log
17 |      *
18 |      * @param  string $name
19 |      * @param  array  $arguments
20 |      * @return void
21 |      */
22 |     public static function __callStatic(string $name, array $arguments = [])
23 |     {
24 |         $instance = app("logger");
25 | 
26 |         call_user_func_array([$instance, $name], $arguments);
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Support/LoggerService.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Support;
 4 | 
 5 | class LoggerService
 6 | {
 7 |     /**
 8 |      * Logger service
 9 |      *
10 |      * @param  string $message
11 |      * @param  array  $context
12 |      * @return void
13 |      */
14 |     public function error(string $message, array $context = []): void
15 |     {
16 |         app('logger')->error($message, $context);
17 |     }
18 | 
19 |     /**
20 |      * Logger service
21 |      *
22 |      * @param  string $message
23 |      * @param  array  $context
24 |      * @return void
25 |      */
26 |     public function info(string $message, array $context = []): void
27 |     {
28 |         app('logger')->info($message, $context);
29 |     }
30 | 
31 |     /**
32 |      * Logger service
33 |      *
34 |      * @param  string $message
35 |      * @param  array  $context
36 |      * @return void
37 |      */
38 |     public function warning(string $message, array $context = []): void
39 |     {
40 |         app('logger')->warning($message, $context);
41 |     }
42 | 
43 |     /**
44 |      * Logger service
45 |      *
46 |      * @param  string $message
47 |      * @param  array  $context
48 |      * @return void
49 |      */
50 |     public function alert(string $message, array $context = []): void
51 |     {
52 |         app('logger')->alert($message, $context);
53 |     }
54 | 
55 |     /**
56 |      * Logger service
57 |      *
58 |      * @param  string $message
59 |      * @param  array  $context
60 |      * @return void
61 |      */
62 |     public function critical(string $message, array $context = []): void
63 |     {
64 |         app('logger')->critical($message, $context);
65 |     }
66 | 
67 |     /**
68 |      * Logger service
69 |      *
70 |      * @param  string $message
71 |      * @param  array  $context
72 |      * @return void
73 |      */
74 |     public function emergency(string $message, array $context = []): void
75 |     {
76 |         app('logger')->emergency($message, $context);
77 |     }
78 | }
79 | 


--------------------------------------------------------------------------------
/src/Testing/Assert.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Testing;
 6 | 
 7 | use PHPUnit\Framework\TestCase;
 8 | 
 9 | class Assert extends TestCase
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Testing/Features/FeatureHelper.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Testing\Features;
 6 | 
 7 | use Faker\Factory;
 8 | use Faker\Generator;
 9 | 
10 | trait FeatureHelper
11 | {
12 |     /**
13 |      * Get fake instance
14 |      *
15 |      * @see    https://github.com/fzaninotto/Faker for all documentation
16 |      * @return Generator
17 |      */
18 |     public function faker(): Generator
19 |     {
20 |         static $faker;
21 | 
22 |         if (is_null($faker)) {
23 |             $faker = Factory::create();
24 |         }
25 | 
26 |         return $faker;
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Testing/Features/Migration.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Testing\Features;
 6 | 
 7 | trait Migration
 8 | {
 9 |     // Do something
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Testing/Features/SeedingHelper.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Testing\Features;
 6 | 
 7 | use ErrorException;
 8 | 
 9 | trait SeedingHelper
10 | {
11 |     /**
12 |      * Seed alias
13 |      *
14 |      * @param  string $seeder
15 |      * @param  array  $data
16 |      * @return int
17 |      * @throws ErrorException
18 |      */
19 |     public function seed(string $seeder, array $data = []): int
20 |     {
21 |         return db_seed($seeder, $data);
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Testing/KernelTesting.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Testing;
 4 | 
 5 | use Bow\Configuration\Loader as ConfigurationLoader;
 6 | 
 7 | class KernelTesting extends ConfigurationLoader
 8 | {
 9 |     private static array $configurations = [];
10 |     private static array $events = [];
11 |     private static array $middlewares = [];
12 | 
13 |     /**
14 |      * Set the loading configuration
15 |      *
16 |      * @param  array $configurations
17 |      * @return void
18 |      */
19 |     public static function withConfigurations(array $configurations): void
20 |     {
21 |         static::$configurations = $configurations;
22 |     }
23 | 
24 |     /**
25 |      * Set the loading events
26 |      *
27 |      * @param  array $events
28 |      * @return void
29 |      */
30 |     public static function withEvents(array $events): void
31 |     {
32 |         static::$events = $events;
33 |     }
34 | 
35 |     /**
36 |      * Set the loading middlewares
37 |      *
38 |      * @param  array $middlewares
39 |      * @return void
40 |      */
41 |     public static function withMiddlewares(array $middlewares): void
42 |     {
43 |         static::$middlewares = $middlewares;
44 |     }
45 | 
46 |     /**
47 |      * @inheritDoc
48 |      */
49 |     public function configurations(): array
50 |     {
51 |         return static::$configurations;
52 |     }
53 | 
54 |     /**
55 |      * @inheritDoc
56 |      */
57 |     public function events(): array
58 |     {
59 |         return static::$events;
60 |     }
61 | 
62 |     /**
63 |      * @inheritDoc
64 |      */
65 |     public function middlewares(): array
66 |     {
67 |         return static::$middlewares;
68 |     }
69 | }
70 | 


--------------------------------------------------------------------------------
/src/Testing/README.md:
--------------------------------------------------------------------------------
 1 | # Bow Testing
 2 | 
 3 | Bow Framework's testing system is the extension of PHPUnit and add the route testing like baby.
 4 | 
 5 | Let's show a little exemple:
 6 | 
 7 | ```php
 8 | use Bow\Testing\TestCase;
 9 | 
10 | class HelloWorldTest extends TestCase
11 | {
12 |     public function test_a_user_can_show_landing_page()
13 |     {
14 |         $response = $this->get('/landing');
15 |         
16 |         $response->assertStatus(200);
17 |         $response->assertContentType('text/html');
18 |     }
19 | }
20 | ```
21 | 


--------------------------------------------------------------------------------
/src/Translate/README.md:
--------------------------------------------------------------------------------
 1 | # Bow Translate
 2 | 
 3 | Bow Framework's translation system is a very simple translation API. Also supports pluralization.
 4 | 
 5 | This is the sample configuration
 6 | 
 7 | ```php
 8 | // frontend/lang/en/messages.php
 9 | return [
10 |   'welcome' => 'Welcome to our application'
11 | ];
12 | ```
13 | 
14 | Let's show a little example:
15 | 
16 | ```php
17 | use Bow\Translate\Translator;
18 | 
19 | echo Translator::translate('messages.welcome');
20 | // Or
21 | echo app_trans('messages.welcome');
22 | ```
23 | 


--------------------------------------------------------------------------------
/src/Translate/TranslatorConfiguration.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Translate;
 6 | 
 7 | use Bow\Configuration\Configuration;
 8 | use Bow\Configuration\Loader;
 9 | 
10 | class TranslatorConfiguration extends Configuration
11 | {
12 |     /**
13 |      * @inheritdoc
14 |      */
15 |     public function create(Loader $config): void
16 |     {
17 |         $this->container->bind(
18 |             'translate',
19 |             function () use ($config) {
20 |                 $auto_detected = $config['translate.auto_detected'] ?? false;
21 |                 $lang = $config['translate.lang'];
22 |                 $dictionary = $config['translate.dictionary'];
23 | 
24 |                 if ($auto_detected) {
25 |                     $lang = app("request")->lang();
26 |                     if (is_string($lang)) {
27 |                         $lang = strtolower($lang);
28 |                     } else {
29 |                         $lang = $config['translate.lang'];
30 |                     }
31 |                 }
32 | 
33 |                 return Translator::configure($lang, $dictionary);
34 |             }
35 |         );
36 |     }
37 | 
38 |     /**
39 |      * @inheritdoc
40 |      */
41 |     public function run(): void
42 |     {
43 |         $this->container->make('translate');
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/Validation/Exception/AuthorizationException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Validation\Exception;
 6 | 
 7 | use Exception;
 8 | 
 9 | class AuthorizationException extends Exception
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Validation/Exception/ValidationException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Validation\Exception;
 6 | 
 7 | use Bow\Http\Exception\HttpException;
 8 | 
 9 | class ValidationException extends HttpException
10 | {
11 |     /**
12 |      * The validation error fields
13 |      *
14 |      * @var array
15 |      */
16 |     private $errors = [];
17 | 
18 |     /**
19 |      * ValidationException constructor
20 |      *
21 |      * @param string $message
22 |      * @param array  $errors
23 |      * @param string $status
24 |      */
25 |     public function __construct(
26 |         string $message,
27 |         array $errors = [],
28 |         string $status = 'VALIDATION_ERROR'
29 |     ) {
30 |         parent::__construct($message, 400);
31 |         $this->errors = $errors;
32 |         $this->status = $status;
33 |     }
34 | 
35 |     /**
36 |      * Get the errors
37 |      *
38 |      * @return array
39 |      */
40 |     public function getErrors()
41 |     {
42 |         return $this->errors;
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/src/Validation/README.md:
--------------------------------------------------------------------------------
 1 | # Bow Validator
 2 | 
 3 | Bow Framework's validator system help developer to make data validation delightful.
 4 | 
 5 | Let's show a little example:
 6 | 
 7 | ```php
 8 | $data = ["name" => "Franck DAKIA"];
 9 | 
10 | $validation = validator($data, [
11 |     "name" => "required|max:50"
12 | ]);
13 | 
14 | if ($validation->fails()) {
15 |     doSomething();
16 |     $validation->getMessages();
17 | }
18 | ```
19 | 


--------------------------------------------------------------------------------
/src/Validation/Rules/DatetimeRule.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Validation\Rules;
 6 | 
 7 | trait DatetimeRule
 8 | {
 9 |     /**
10 |      * Compile Date Rule
11 |      *
12 |      * [date] Check that the field's content is a valid date
13 |      *
14 |      * @param  string $key
15 |      * @param  string $masque
16 |      * @return void
17 |      */
18 |     protected function compileDate(string $key, string $masque): void
19 |     {
20 |         if (!preg_match("/^date?$/", $masque, $match)) {
21 |             return;
22 |         }
23 | 
24 |         if (!preg_match('/^[0-9]{4}-[0-9]{2}-[0-9]{2}$/', $this->inputs[$key])) {
25 |             return;
26 |         }
27 | 
28 |         $this->fails = true;
29 | 
30 |         $this->last_message = $this->lexical('date', $key);
31 | 
32 |         $this->errors[$key][] = [
33 |             "masque" => $masque,
34 |             "message" => $this->last_message
35 |         ];
36 |     }
37 | 
38 |     /**
39 |      * Compile Date Time Rule
40 |      *
41 |      * [datetime] Check that the contents of the field is a valid date time
42 |      *
43 |      * @param  string $key
44 |      * @param  string $masque
45 |      * @return void
46 |      */
47 |     protected function compileDateTime(string $key, string $masque): void
48 |     {
49 |         if (!preg_match("/^datetime$/", $masque, $match)) {
50 |             return;
51 |         }
52 | 
53 |         if (
54 |             !preg_match(
55 |                 '/^[0-9]{4}-[0-9]{2}-[0-9]{2} [0-9]{2}:[0-9]{2}:[0-9]{2}$/i',
56 |                 $this->inputs[$key]
57 |             )
58 |         ) {
59 |             return;
60 |         }
61 | 
62 |         $this->last_message = $this->lexical('datetime', $key);
63 | 
64 |         $this->fails = true;
65 | 
66 |         $this->errors[$key][] = [
67 |             "masque" => $masque,
68 |             "message" => $this->last_message
69 |         ];
70 |     }
71 | }
72 | 


--------------------------------------------------------------------------------
/src/Validation/Rules/EmailRule.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Validation\Rules;
 6 | 
 7 | use Bow\Support\Str;
 8 | 
 9 | trait EmailRule
10 | {
11 |     /**
12 |      * Compile Email Rule
13 |      *
14 |      * [email] Check that the content of the field is an email
15 |      *
16 |      * @param  string $key
17 |      * @param  string $masque
18 |      * @return void
19 |      */
20 |     protected function compileEmail(string $key, string $masque): void
21 |     {
22 |         if (!preg_match("/^email$/", $masque, $match)) {
23 |             return;
24 |         }
25 | 
26 |         if (Str::isMail($this->inputs[$key])) {
27 |             return;
28 |         }
29 | 
30 |         $this->last_message = $this->lexical('email', $key);
31 | 
32 |         $this->fails = true;
33 | 
34 |         $this->errors[$key][] = [
35 |             "masque" => $masque,
36 |             "message" => $this->last_message
37 |         ];
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Validation/Rules/RegexRule.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Validation\Rules;
 6 | 
 7 | trait RegexRule
 8 | {
 9 |     /**
10 |      * Compile Regex Rule
11 |      *
12 |      * Check that the contents of the field with a regular expression
13 |      *
14 |      * @param  string           $key
15 |      * @param  string|int|float $masque
16 |      * @return void
17 |      */
18 |     protected function compileRegex(string $key, string|int|float $masque): void
19 |     {
20 |         if (!preg_match("/^regex:(.+)+$/", (string)$masque, $match)) {
21 |             return;
22 |         }
23 | 
24 |         $regex = '~' . addcslashes($match[1], "~") . '~';
25 | 
26 |         if (preg_match($regex, $this->inputs[$key])) {
27 |             return;
28 |         }
29 | 
30 |         $this->fails = true;
31 | 
32 |         $this->last_message = $this->lexical('regex', $key);
33 | 
34 |         $this->errors[$key][] = [
35 |             "masque" => $masque,
36 |             "message" => $this->last_message
37 |         ];
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Validation/stubs/lexical.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | return [
 4 |     'email' => 'The {attribute} field must be an email.',
 5 |     'required' => 'The {attribute} field is required.',
 6 |     'empty' => 'The {attribute} field is missing in the fields to be validated.',
 7 |     'min' => 'The {attribute} field must be at least {length} characters long.',
 8 |     'max' => 'The {attribute} field must not exceed {length} characters.',
 9 |     'same' => 'The {attribute} field must be the same as {value}.',
10 |     'number' => 'The {attribute} field must be a number.',
11 |     'int' => 'The {attribute} field must be an integer.',
12 |     'float' => 'The {attribute} field must be a decimal.',
13 |     'alphanum' => 'Only alphanumeric characters are allowed for field {attribute}.',
14 |     'in' => 'The {attribute} field must be one of the following {value}.',
15 |     'size' => 'The {attribute} field must be {length} characters long.',
16 |     'lower' => 'Only lowercase letters are allowed for field {attribute}.',
17 |     'upper' => 'Only uppercase letters are allowed for field {attribute}.',
18 |     'alpha' => 'Only alphabetic characters are allowed for field {attribute}.',
19 |     'exists' => 'The {attribute} field does not exists.',
20 |     'not_exists' => 'The {attribute} field already exists.',
21 |     'unique' => 'The {attribute} field must be unique.',
22 |     'date' => 'The {attribute} field must use the format: yyyy-mm-dd',
23 |     'datetime' => 'The {attribute} field must use the format: yyyy-mm-dd hh:mm:ss',
24 |     'regex' => 'The {attribute} field does not match the pattern',
25 | ];
26 | 


--------------------------------------------------------------------------------
/src/View/Exception/ViewException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\View\Exception;
 6 | 
 7 | use ErrorException;
 8 | 
 9 | class ViewException extends ErrorException
10 | {
11 | }
12 | 


--------------------------------------------------------------------------------
/src/View/README.md:
--------------------------------------------------------------------------------
 1 | # Bow View
 2 | 
 3 | Bow Framework's view system is powerful and big simple template engine.
 4 | 
 5 | We take this template file `template.tintin.php`
 6 | 
 7 | ```html
 8 | Show the legend message of programming learn
 9 | <h1>Hello {{name}}</h1>
10 | ```
11 | 
12 | Rendre the template file:
13 | 
14 | ```php
15 | use Bow\View\View;
16 | 
17 | $content = View::parse("template", ['name' => 'papac']);
18 | ```
19 | 
20 | The output
21 | 
22 | ```html
23 | Show the legend message of programming learn
24 | <h1>Hello papac</h1>
25 | ```
26 | 


--------------------------------------------------------------------------------
/src/View/ViewConfiguration.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\View;
 6 | 
 7 | use Bow\Configuration\Configuration;
 8 | use Bow\Configuration\Loader;
 9 | 
10 | class ViewConfiguration extends Configuration
11 | {
12 |     /**
13 |      * @inheritdoc
14 |      */
15 |     public function create(Loader $config): void
16 |     {
17 |         $this->container->bind(
18 |             'view',
19 |             function () use ($config) {
20 |                 View::configure($config["view"]);
21 | 
22 |                 return View::getInstance();
23 |             }
24 |         );
25 |     }
26 | 
27 |     /**
28 |      * @inheritdoc
29 |      */
30 |     public function run(): void
31 |     {
32 |         $this->container->make('view');
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/tests/.gitkeep:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/tests/Auth/Stubs/UserModelStub.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Tests\Auth\Stubs;
 4 | 
 5 | use Bow\Auth\Authentication;
 6 | 
 7 | class UserModelStub extends Authentication
 8 | {
 9 |     protected string $table = "users";
10 | 
11 |     protected array $hidden = [
12 |         "password"
13 |     ];
14 | }
15 | 


--------------------------------------------------------------------------------
/tests/Config/ConfigurationTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Tests\Config;
 4 | 
 5 | use Bow\Configuration\Loader as ConfigurationLoader;
 6 | 
 7 | class ConfigurationTest extends \PHPUnit\Framework\TestCase
 8 | {
 9 |     private ConfigurationLoader $config;
10 | 
11 |     public function setUp(): void
12 |     {
13 |         $this->config = ConfigurationLoader::configure(__DIR__ . '/stubs');
14 |     }
15 | 
16 |     public function test_instance_of_loader()
17 |     {
18 |         $this->assertInstanceOf(ConfigurationLoader::class, $this->config);
19 |     }
20 | 
21 |     public function test_access_to_values()
22 |     {
23 |         $this->assertIsArray($this->config["stub"]);
24 |         $this->assertNull($this->config["key_not_found"]);
25 |         $this->assertEquals($this->config["stub"]["name"], "papac");
26 |         $this->assertEquals($this->config["stub"]["sub"]["framework"], "bowphp");
27 | 
28 |         $this->assertEquals($this->config["stub.name"], "papac");
29 |         $this->assertIsArray($this->config["stub.sub"]);
30 |         $this->assertEquals($this->config["stub.sub.framework"], "bowphp");
31 |     }
32 | 
33 |     // public function test_set_config_values()
34 |     // {
35 |     //     $this->config["stub"]["name"] = "franck";
36 |     //     $this->config["stub"]["sub"] = [
37 |     //         "job" => "dev"
38 |     //     ];
39 |     //     $this->assertIsArray($this->config["stub"]);
40 |     //     $this->assertNull($this->config["key_not_found"]);
41 |     //     $this->assertEquals($this->config["stub"]["name"], "franck");
42 |     //     $this->assertEquals($this->config["stub"]["sub"]["framework"], "bowphp");
43 |     //     $this->assertEquals($this->config["stub"]["sub"]["job"], "dev");
44 |     // }
45 | }
46 | // I want to rewrite the internal dotnotion for config loader
47 | 


--------------------------------------------------------------------------------
/tests/Config/TestingConfiguration.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Tests\Config;
 4 | 
 5 | use Bow\Configuration\Loader as ConfigurationLoader;
 6 | use Bow\Testing\KernelTesting;
 7 | 
 8 | class TestingConfiguration
 9 | {
10 |     /**
11 |      * TestingConfiguration constructor
12 |      */
13 |     public function __construct()
14 |     {
15 |         is_dir(TESTING_RESOURCE_BASE_DIRECTORY) || mkdir(TESTING_RESOURCE_BASE_DIRECTORY);
16 |     }
17 | 
18 |     /**
19 |      * Configure the testing
20 |      *
21 |      * @param array $configurations
22 |      * @return void
23 |      */
24 |     public static function withConfigurations(array $configurations): void
25 |     {
26 |         KernelTesting::withConfigurations($configurations);
27 |     }
28 | 
29 |     /**
30 |      * Configure the testing
31 |      *
32 |      * @param array $middlewares
33 |      * @return void
34 |      */
35 |     public static function withMiddlewares(array $middlewares): void
36 |     {
37 |         KernelTesting::withMiddlewares($middlewares);
38 |     }
39 | 
40 |     /**
41 |      * Set the loading events
42 |      *
43 |      * @param array $events
44 |      * @return void
45 |      */
46 |     public static function withEvents(array $events): void
47 |     {
48 |         KernelTesting::withEvents($events);
49 |     }
50 | 
51 |     /**
52 |      * Get the configuration for testing
53 |      *
54 |      * @return ConfigurationLoader
55 |      */
56 |     public static function getConfig(): ConfigurationLoader
57 |     {
58 |         return KernelTesting::configure(__DIR__ . '/stubs');
59 |     }
60 | }
61 | 


--------------------------------------------------------------------------------
/tests/Config/stubs/.key:
--------------------------------------------------------------------------------
1 | 0d9be6376fc57f04029ba40a8443e0274110ff1f
2 | 


--------------------------------------------------------------------------------
/tests/Config/stubs/app.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | return [
4 |     "root" => "",
5 |     "auto_csrf" => false,
6 |     "env_file" => realpath(__DIR__ . "/../../Support/stubs/env.json"),
7 | ];
8 | 


--------------------------------------------------------------------------------
/tests/Config/stubs/auth.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Bow\Tests\Auth\Stubs\UserModelStub;
 4 | 
 5 | return [
 6 |     /**
 7 |      * Branch by default of connection
 8 |      */
 9 |     "default" => "web",
10 | 
11 |     /**
12 |      * Default authentication branch
13 |      */
14 |     "web" => [
15 |         "type" => "session",
16 |         'model' => UserModelStub::class,
17 |         'credentials' => [
18 |             'username' => 'username',
19 |             'password' => 'password'
20 |         ]
21 |     ],
22 | 
23 |     /**
24 |      * Default authentication branch
25 |      */
26 |     "api" => [
27 |         "type" => "jwt",
28 |         'model' => UserModelStub::class,
29 |         'credentials' => [
30 |             'username' => 'username',
31 |             'password' => 'password'
32 |         ]
33 |     ],
34 | ];
35 | 


--------------------------------------------------------------------------------
/tests/Config/stubs/cache.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | return [
 4 |     "default" => "file",
 5 | 
 6 |     "stores" => [
 7 |         "file" => [
 8 |             "driver" => "file",
 9 |             "path" => TESTING_RESOURCE_BASE_DIRECTORY
10 |         ],
11 | 
12 |         "database" => [
13 |             "driver" => "database",
14 |             "connection" => "mysql",
15 |             "table" => "caches",
16 |         ],
17 | 
18 |         // The redis connection
19 |         "redis" => [
20 |             'driver' => 'redis',
21 |             'database' => app_env('REDIS_CACHE_DB', 5),
22 |             "prefix" => "__app__",
23 |         ]
24 |     ]
25 | ];
26 | 


--------------------------------------------------------------------------------
/tests/Config/stubs/mail.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | return [
 4 |     'driver' => 'smtp',
 5 |     'charset' => 'utf8',
 6 | 
 7 |     'smtp' => [
 8 |         'hostname' => 'localhost',
 9 |         'username' => 'test@test.dev',
10 |         'password' => null,
11 |         'port' => 1025,
12 |         'tls' => false,
13 |         'ssl' => false,
14 |         'timeout' => 150,
15 |     ],
16 | 
17 |     'mail' => [
18 |         'default' => 'contact',
19 |         'from' => [
20 |             'contact' => [
21 |                 'address' => app_env('MAIL_FROM_EMAIL'),
22 |                 'name' => app_env('MAIL_FROM_NAME')
23 |             ],
24 |             'info' => [
25 |                 'address' => 'info@exemple.com',
26 |                 'username' => 'Address information'
27 |             ]
28 |         ]
29 |     ]
30 | ];
31 | 


--------------------------------------------------------------------------------
/tests/Config/stubs/policier.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | return [
 4 |     "signkey" => "FivwuTmpJlwfXB/WMjAyMS0wMS0yNCAyMDozMTozMTE2MTE1MjAyOTEuMDEwOA==",
 5 | 
 6 |     /**
 7 |      * Token expiration time
 8 |      */
 9 |     "exp" => 3600 * 24 * 3,
10 | 
11 |     /**
12 |      * Configures the issuer
13 |      */
14 |     "iss" => app_env("APP_JWT_ISSUER", "app.example.com"),
15 | 
16 |     /**
17 |      * Configures the audience
18 |      */
19 |     "aud" => app_env("APP_JWT_AUD", "app.example.com"),
20 | 
21 |     /**
22 |      * Token is usable after this time
23 |      */
24 |     "nbf" => 60,
25 | 
26 |     /**
27 |      * Token was issue
28 |      */
29 |     "iat" => 60,
30 | 
31 |     /**
32 |      * The type of the token, which is JWT
33 |      */
34 |     "typ" => "JWT",
35 | 
36 |     /**
37 |      * Hashing algorithm being used
38 |      *
39 |      * HS256, HS384, HS512, ES256, ES384, ES512,
40 |      */
41 |     "alg" => "HS512",
42 | ];
43 | 


--------------------------------------------------------------------------------
/tests/Config/stubs/queue.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | return [
 4 |     /**
 5 |      * The defaut connexion
 6 |      */
 7 |     "default" => "sync",
 8 | 
 9 |     /**
10 |      * The queue drive connection
11 |      */
12 |     "connections" => [
13 |         /**
14 |          * The sync connexion
15 |          */
16 |         "sync" => [
17 |             "directory" => TESTING_RESOURCE_BASE_DIRECTORY . "/queue"
18 |         ],
19 | 
20 |         /**
21 |          * The beanstalkd connexion
22 |          */
23 |         "beanstalkd" => [
24 |             "hostname" => "127.0.0.1",
25 |             "port" => 11300,
26 |             "timeout" => 10,
27 |         ],
28 | 
29 |         /**
30 |          * The sqs connexion
31 |          */
32 |         "sqs" => [
33 |             'profile' => 'default',
34 |             'region' => 'ap-south-1',
35 |             'version' => 'latest',
36 |             'url' => getenv("AWS_SQS_URL"),
37 |             'credentials' => [
38 |                 'key' => getenv('AWS_KEY'),
39 |                 'secret' => getenv('AWS_SECRET'),
40 |             ],
41 |         ],
42 | 
43 |         /**
44 |          * The sqs connexion
45 |          */
46 |         "database" => [
47 |             'table' => "queues",
48 |         ]
49 |     ]
50 | ];
51 | 


--------------------------------------------------------------------------------
/tests/Config/stubs/security.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | return [
 4 |     /**
 5 |      * Security key of the application
 6 |      * Can be reorder by the command
 7 |      * <code>`php bow generate:key`</code>
 8 |      */
 9 |     'key' => file_get_contents(__DIR__ . '/.key'),
10 | 
11 |     /**
12 |      * The Encrypt method
13 |      */
14 |     'cipher' => 'AES-256-CBC',
15 | 
16 |     /**
17 |      * The Hash method
18 |      *
19 |      * @see https://github.com/bowphp/framework/issues/55
20 |      */
21 |     'hash_method' => PASSWORD_BCRYPT,
22 | 
23 |     /**
24 |      * The Hash method options
25 |      *
26 |      * @see https://www.php.net/manual/fr/password.constants.php
27 |      */
28 |     'hash_options' => [
29 |         'cost' => 10
30 |     ],
31 | 
32 |     /**
33 |      * When using token. This is the life time of a token.
34 |      * It is strongly advised to program with tokens.
35 |      */
36 |     'token_expirate_time' => 50000
37 | ];
38 | 


--------------------------------------------------------------------------------
/tests/Config/stubs/storage.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | return [
 4 |     /**
 5 |      * Repertoire de log
 6 |      */
 7 |     'log' => TESTING_RESOURCE_BASE_DIRECTORY,
 8 | 
 9 |     /**
10 |      * Store location
11 |      */
12 |     'disk' => [
13 |         'mount' => 'storage',
14 |         'path' => [
15 |             'storage' => TESTING_RESOURCE_BASE_DIRECTORY,
16 |             'public' => TESTING_RESOURCE_BASE_DIRECTORY,
17 |         ]
18 |     ],
19 | 
20 |     'services' => [
21 |         /**
22 |          * FTP configuration
23 |          */
24 |         'ftp' => [
25 |             "driver" => "ftp",
26 |             'hostname' => app_env('FTP_HOST', 'localhost'),
27 |             'password' => app_env('FTP_PASSWORD', 'password'),
28 |             'username' => app_env('FTP_USERNAME', 'username'),
29 |             'port' => app_env('FTP_PORT', 21),
30 |             'root' => app_env('FTP_ROOT', '/tmp'), // Start directory
31 |             'tls' => app_env('FTP_SSL', false), // `true` enable the secure connexion.
32 |             'timeout' => app_env('FTP_TIMEOUT', 90) // Temps d'attente de connection
33 |         ],
34 | 
35 |         /**
36 |          * S3 configuration
37 |          */
38 |         's3' => [
39 |             "driver" => "s3",
40 |             'credentials' => [
41 |                 'key' => getenv('AWS_KEY'),
42 |                 'secret' => getenv('AWS_SECRET'),
43 |             ],
44 |             'bucket' => getenv('AWS_S3_BUCKET'),
45 |             'region' => 'us-east-1',
46 |             'version' => 'latest'
47 |         ]
48 |     ],
49 | ];
50 | 


--------------------------------------------------------------------------------
/tests/Config/stubs/stub.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | return [
4 |     "name" => "papac",
5 |     "sub" => [
6 |         "framework" => "bowphp"
7 |     ],
8 | ];
9 | 


--------------------------------------------------------------------------------
/tests/Config/stubs/translate.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | return [
 4 |     /**
 5 |      * Default language
 6 |      */
 7 |     'lang' => 'fr',
 8 | 
 9 |     /**
10 |      * When the value is true, the translation system
11 |      * will detect the language of the client and will translate according to
12 |      */
13 |     'auto_detected' => false,
14 | 
15 |     /**
16 |      * Path to the language repeater
17 |      */
18 |     'dictionary' => __DIR__ . '/../../Translate/stubs',
19 | ];
20 | 


--------------------------------------------------------------------------------
/tests/Config/stubs/view.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | return [
 4 |     // twig, tintin, php
 5 |     'engine' => 'twig',
 6 | 
 7 |     // Extension des pages de vues
 8 |     'extension' => '.twig',
 9 | 
10 |     // Le repertoire de cache.
11 |     'cache' => TESTING_RESOURCE_BASE_DIRECTORY . '/cache',
12 | 
13 |     // Le repertoire des vues.
14 |     'path' => realpath(__DIR__ . '/../../View/stubs'),
15 | 
16 |     'additionnal_options' => [
17 |         'auto_reload' => true
18 |     ]
19 | ];
20 | 


--------------------------------------------------------------------------------
/tests/Console/CustomCommandTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Tests\Console\Stubs;
 4 | 
 5 | use Bow\Console\Console;
 6 | use Bow\Console\Setting;
 7 | 
 8 | class CustomCommandTest extends \PHPUnit\Framework\TestCase
 9 | {
10 |     private static Console $console;
11 | 
12 |     public static function setUpBeforeClass(): void
13 |     {
14 |         // This define the command like this `php bow command`
15 |         $GLOBALS["argv"] = ["command"];
16 | 
17 |         $setting = new Setting(TESTING_RESOURCE_BASE_DIRECTORY);
18 |         static::$console = new Console($setting);
19 |     }
20 | 
21 |     public function test_create_the_custom_command_from_static_calling()
22 |     {
23 |         Console::register("command", CustomCommand::class);
24 |         static::$console->call("command");
25 | 
26 |         $content = $this->getFileContent();
27 |         $this->assertEquals($content, 'ok');
28 | 
29 |         $this->clearFile();
30 |     }
31 | 
32 |     public function test_create_the_custom_command_from_instance_calling()
33 |     {
34 |         static::$console->addCommand("command", CustomCommand::class);
35 |         static::$console->call("command");
36 | 
37 |         $content = $this->getFileContent();
38 |         $this->assertEquals($content, 'ok');
39 | 
40 |         $this->clearFile();
41 |     }
42 | 
43 |     protected function getFileContent()
44 |     {
45 |         return file_get_contents(TESTING_RESOURCE_BASE_DIRECTORY . '/test_custom_command.txt');
46 |     }
47 | 
48 |     protected function clearFile()
49 |     {
50 |         file_put_contents(TESTING_RESOURCE_BASE_DIRECTORY . '/test_custom_command.txt', '');
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/tests/Console/GeneratorBasicTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Tests\Console;
 4 | 
 5 | use Bow\Console\Generator;
 6 | 
 7 | class GeneratorBasicTest extends \PHPUnit\Framework\TestCase
 8 | {
 9 |     public function test_generate_stubs()
10 |     {
11 |         $generator = new Generator(TESTING_RESOURCE_BASE_DIRECTORY, 'CreateUserCommand');
12 |         $content = $generator->makeStubContent('command', [
13 |             "namespace" => "",
14 |             "className" => "CreateUserCommand",
15 |             "baseNamespace" => "Generator\Testing",
16 |         ]);
17 | 
18 |         $this->assertNotNull($content);
19 |         $this->assertMatchesRegularExpression("@\nnamespace\sGenerator\\\Testing;\n@", $content);
20 |         $this->assertMatchesRegularExpression("@\nclass\sCreateUserCommand\sextends\sConsoleCommand\n@", $content);
21 |     }
22 | 
23 |     public function test_generate_stub_without_data()
24 |     {
25 |         $generator = new Generator(TESTING_RESOURCE_BASE_DIRECTORY, 'CreateUserCommand');
26 |         $content = $generator->makeStubContent('command');
27 | 
28 |         $this->assertNotNull($content);
29 |         $this->assertMatchesRegularExpression("@\nnamespace\s\{baseNamespace\}\{namespace\};\n@", $content);
30 |         $this->assertMatchesRegularExpression("@\nclass\s\{className\}\sextends\sConsoleCommand\n@", $content);
31 |     }
32 | 
33 |     public function test_generate_by_writing_file()
34 |     {
35 |         $generator = new Generator(TESTING_RESOURCE_BASE_DIRECTORY, 'CreateUserCommand');
36 |         $result = $generator->write('command', [
37 |             "baseNamespace" => "Generator\Testing",
38 |         ]);
39 | 
40 |         $this->assertTrue($result);
41 |         $this->assertTrue(file_exists($generator->getPath()));
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/tests/Console/Stubs/CustomCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Tests\Console\Stubs;
 4 | 
 5 | use Bow\Console\AbstractCommand as ConsoleCommand;
 6 | 
 7 | class CustomCommand extends ConsoleCommand
 8 | {
 9 |     public function process()
10 |     {
11 |         file_put_contents(TESTING_RESOURCE_BASE_DIRECTORY . '/test_custom_command.txt', 'ok');
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/tests/Console/__snapshots__/GeneratorDeepTest__test_generate_cache_migration_stubs__1.txt:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Bow\Database\Migration\Migration;
 4 | use Bow\Database\Migration\Table;
 5 | 
 6 | class FakeCacheMigration extends Migration
 7 | {
 8 |     /**
 9 |      * Up Migration
10 |      */
11 |     public function up(): void
12 |     {
13 |         $this->create("caches", function (Table $table) {
14 |             $table->addString('key_name', ['primary' => true, 'size' => 500]);
15 |             $table->addText('data');
16 |             $table->addDatetime('expire', ['nullable' => true]);
17 |             $table->addTimestamps();
18 |         });
19 |     }
20 | 
21 |     /**
22 |      * Rollback migration
23 |      */
24 |     public function rollback(): void
25 |     {
26 |         $this->dropIfExists("caches");
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/tests/Console/__snapshots__/GeneratorDeepTest__test_generate_command_stubs__1.txt:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Commands;
 4 | 
 5 | use Bow\Console\AbstractCommand as ConsoleCommand;
 6 | 
 7 | class FakeCommand extends ConsoleCommand
 8 | {
 9 |     /**
10 |      * Handle console action
11 |      * 
12 |      * @return void
13 |      */
14 |     public function process(): void
15 |     {
16 |         //
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/tests/Console/__snapshots__/GeneratorDeepTest__test_generate_configuration_stubs__1.txt:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Configurations;
 4 | 
 5 | use Bow\Configuration\Loader;
 6 | use Bow\Configuration\Configuration;
 7 | 
 8 | class FakeConfiguration extends Configuration
 9 | {
10 |     /**
11 |      * Launch configuration
12 |      *
13 |      * @param Loader $config
14 |      * @return void
15 |      */
16 |     public function create(Loader $config): void
17 |     {
18 |         //
19 |     }
20 | 
21 |     /**
22 |      * Start the configured package
23 |      *
24 |      * @return void
25 |      */
26 |     public function run(): void
27 |     {
28 |         //
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/tests/Console/__snapshots__/GeneratorDeepTest__test_generate_controller_no_plain_stubs__1.txt:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Controllers;
 4 | 
 5 | use App\\Controller;
 6 | use Bow\Http\Request;
 7 | 
 8 | class ExampleController extends Controller
 9 | {
10 |     /**
11 |      * Application entry point
12 |      *
13 |      * @return void
14 |      */
15 |     public function index(): void
16 |     {
17 |         // Code Here
18 |     }
19 | 
20 |     /**
21 |      * Displays the view for creating a resource.
22 |      *
23 |      * @param Request $request
24 |      * @return void
25 |      */
26 |     public function create(): void
27 |     {
28 |         // Code Here
29 |     }
30 | 
31 |     /**
32 |      * Add a new resource in the information base
33 |      *
34 |      * @param Request $request
35 |      * @return void
36 |      */
37 |     public function store(Request $request): void
38 |     {
39 |         // Code Here
40 |     }
41 | 
42 |     /**
43 |      * Allows you to retrieve precise information with an identifier.
44 |      *
45 |      * @param  mixed $id
46 |      * @return void
47 |      */
48 |     public function show(mixed $id): void
49 |     {
50 |         // Code Here
51 |     }
52 | 
53 |     /**
54 |      * Show updating form using GET
55 |      *
56 |      * @param  mixed $id
57 |      * @return void
58 |      */
59 |     public function edit(mixed $id): void
60 |     {
61 |         // Code Here
62 |     }
63 | 
64 |     /**
65 |      * Update a resource
66 |      *
67 |      * @param Request $request
68 |      * @param  mixed $id
69 |      * @return void
70 |      */
71 |     public function update(Request $request, mixed $id): void
72 |     {
73 |         // Code Here
74 |     }
75 | 
76 |     /**
77 |      * Delete a resource
78 |      *
79 |      * @param mixed $id
80 |      * @return void
81 |      */
82 |     public function destroy(mixed $id): void
83 |     {
84 |         // Code Here
85 |     }
86 | }
87 | 


--------------------------------------------------------------------------------
/tests/Console/__snapshots__/GeneratorDeepTest__test_generate_controller_rest_stubs__1.txt:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Controllers;
 4 | 
 5 | {modelNamespace}use App\\Controller;
 6 | use Bow\Http\Request;
 7 | 
 8 | class ExampleController extends Controller
 9 | {
10 |     /**
11 |      * Start point
12 |      *
13 |      * GET {prefix}
14 |      *
15 |      * @return void
16 |      */
17 |     public function index(): void
18 |     {
19 |         // Code Here
20 |     }
21 | 
22 |     /**
23 |      * Add a new resource in the information base
24 |      *
25 |      * POST {prefix}
26 |      *
27 |      * @param Request $request
28 |      * @return void
29 |      */
30 |     public function store(Request $request): void
31 |     {
32 |         // Code Here
33 |     }
34 | 
35 |     /**
36 |      * Allows you to retrieve specific information with an identifier.
37 |      *
38 |      * GET {prefix}/:id
39 |      *
40 |      * @param Request $request
41 |      * @param mixed $id
42 |      * @return void
43 |      */
44 |     public function show(Request $request, mixed $id): void
45 |     {
46 |         // Code Here
47 |     }
48 | 
49 |     /**
50 |      * Updating a resource
51 |      *
52 |      * PUT {prefix}/:id
53 |      *
54 |      * @param Request $request
55 |      * @param mixed $id
56 |      * @return void
57 |      */
58 |     public function update(Request $request, mixed $id): void
59 |     {
60 |         // Code Here
61 |     }
62 | 
63 |     /**
64 |      * Delete a resource
65 |      *
66 |      * DELETE {prefix}/:id
67 |      *
68 |      * @param Request $request
69 |      * @param mixed $id
70 |      * @return void
71 |      */
72 |     public function destroy(Request $request, mixed $id): void
73 |     {
74 |         // Code Here
75 |     }
76 | }
77 | 


--------------------------------------------------------------------------------
/tests/Console/__snapshots__/GeneratorDeepTest__test_generate_controller_stubs__1.txt:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Controllers;
 4 | 
 5 | use App\\Controller;
 6 | use Bow\Http\Request;
 7 | 
 8 | class ExampleController extends Controller
 9 | {
10 |     //
11 | }
12 | 


--------------------------------------------------------------------------------
/tests/Console/__snapshots__/GeneratorDeepTest__test_generate_create_migration_stubs__1.txt:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Bow\Database\Migration\Migration;
 4 | use Bow\Database\Migration\Table;
 5 | 
 6 | class FakeCreateTableMigration extends Migration
 7 | {
 8 |     /**
 9 |      * Up Migration
10 |      */
11 |     public function up(): void
12 |     {
13 |         $this->create("fakers", function (Table $table) {
14 |             $table->addIncrement('id');
15 |             $table->addTimestamps();
16 |         });
17 |     }
18 | 
19 |     /**
20 |      * Rollback migration
21 |      */
22 |     public function rollback(): void
23 |     {
24 |         $this->dropIfExists("fakers");
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/tests/Console/__snapshots__/GeneratorDeepTest__test_generate_event_stubs__1.txt:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Events;
 4 | 
 5 | use Bow\Event\Contracts\AppEvent;
 6 | use Bow\Event\Dispatchable;
 7 | use Bow\Support\Serializes;
 8 | 
 9 | class FakeEvent implements AppEvent
10 | {
11 | 	use Dispatchable, Serializes;
12 | 
13 |     /**
14 |      * Create a new event instance.
15 |      */
16 |     public function __construct()
17 |     {
18 |         // Do something here
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/tests/Console/__snapshots__/GeneratorDeepTest__test_generate_exception_stubs__1.txt:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Exceptions;
 4 | 
 5 | use Exception;
 6 | 
 7 | class FakeException extends Exception
 8 | {
 9 |     // do something here
10 | }
11 | 


--------------------------------------------------------------------------------
/tests/Console/__snapshots__/GeneratorDeepTest__test_generate_listener_stubs__1.txt:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Listeners;
 4 | 
 5 | use Bow\Event\Contracts\EventListener;
 6 | 
 7 | class FakeListener implements EventListener
 8 | {
 9 | 	/**
10 | 	 * Process the event
11 | 	 * 
12 | 	 * @param mixed $event
13 | 	 * @return void
14 | 	 */
15 | 	public function process($event): void
16 | 	{
17 |         // do something here
18 | 	}
19 | }
20 | 


--------------------------------------------------------------------------------
/tests/Console/__snapshots__/GeneratorDeepTest__test_generate_messaging_stubs__1.txt:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Messages;
 4 | 
 5 | use Bow\Database\Barry\Model;
 6 | use Bow\Mail\Envelop;
 7 | use Bow\Messaging\Messaging;
 8 | 
 9 | class WelcomeMessage extends Messaging
10 | {
11 |     /**
12 |      * Returns the available channels to be used
13 |      *
14 |      * @param Model $notifiable
15 |      * @return array
16 |      */
17 |     public function channels(Model $notifiable): array
18 |     {
19 |         return ['mail', 'database'];
20 |     }
21 | 
22 |     /**
23 |      * Send notification to mail
24 |      *
25 |      * @param Model $notifiable
26 |      * @return Envelop|null
27 |      */
28 |     public function toMail(Model $notifiable): ?Envelop
29 |     {
30 |         return (new Envelop());
31 |     }
32 | 
33 |     /**
34 |      * Send notification to database
35 |      *
36 |      * @param Model $notifiable
37 |      * @return array
38 |      */
39 |     public function toDatabase(Model $notifiable): array
40 |     {
41 |         return [];
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/tests/Console/__snapshots__/GeneratorDeepTest__test_generate_middleware_stubs__1.txt:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Middlewares;
 4 | 
 5 | use Bow\Http\Request;
 6 | use Bow\Middleware\BaseMiddleware;
 7 | 
 8 | class FakeMiddleware implements BaseMiddleware
 9 | {
10 |     /**
11 |      * Handle an incoming request.
12 |      *
13 |      * @param Request $request
14 |      * @param callable $next
15 |      * @param array $args
16 |      * @return mixed
17 |      */
18 |     public function process(Request $request, callable $next, array $args = []): mixed
19 |     {
20 |         // Code Here
21 | 
22 |         return $next($request);
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/tests/Console/__snapshots__/GeneratorDeepTest__test_generate_model_cache_stubs__1.txt:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Bow\Database\Migration\Migration;
 4 | use Bow\Database\Migration\SQLGenerator;
 5 | 
 6 | class FakeCacheMigration extends Migration
 7 | {
 8 |     /**
 9 |      * Up Migration
10 |      */
11 |     public function up(): void
12 |     {
13 |         $this->create("caches", function (SQLGenerator $table) {
14 |             $table->addString('key_name', ['primary' => true, 'size' => 500]);
15 |             $table->addText('data');
16 |             $table->addDatetime('expire', ['nullable' => true]);
17 |             $table->addTimestamps();
18 |         });
19 |     }
20 | 
21 |     /**
22 |      * Rollback migration
23 |      */
24 |     public function rollback(): void
25 |     {
26 |         $this->dropIfExists("caches");
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/tests/Console/__snapshots__/GeneratorDeepTest__test_generate_model_create_stubs__1.txt:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Bow\Database\Migration\Migration;
 4 | use Bow\Database\Migration\SQLGenerator;
 5 | 
 6 | class FakeCreateTableMigration extends Migration
 7 | {
 8 |     /**
 9 |      * Up Migration
10 |      */
11 |     public function up(): void
12 |     {
13 |         $this->create("fakers", function (SQLGenerator $table) {
14 |             $table->addIncrement('id');
15 |             $table->addTimestamps();
16 |         });
17 |     }
18 | 
19 |     /**
20 |      * Rollback migration
21 |      */
22 |     public function rollback(): void
23 |     {
24 |         $this->dropIfExists("fakers");
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/tests/Console/__snapshots__/GeneratorDeepTest__test_generate_model_migration_stubs__1.txt:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Models;
 4 | 
 5 | use Bow\Database\Barry\Model;
 6 | 
 7 | class Example extends Model
 8 | {
 9 |     //
10 | }
11 | 


--------------------------------------------------------------------------------
/tests/Console/__snapshots__/GeneratorDeepTest__test_generate_model_session_stubs__1.txt:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Bow\Database\Migration\Migration;
 4 | use Bow\Database\Migration\SQLGenerator;
 5 | 
 6 | class FakeSessionMigration extends Migration
 7 | {
 8 |     /**
 9 |      * Up Migration
10 |      */
11 |     public function up(): void
12 |     {
13 |         $this->create("sessions", function (SQLGenerator $table) {
14 |             $table->addColumn('id', 'string', ['primary' => true]);
15 |             $table->addColumn('time', 'timestamp');
16 |             $table->addColumn('data', 'text');
17 |             $table->addColumn('ip', 'string');
18 |         });
19 |     }
20 | 
21 |     /**
22 |      * Rollback migration
23 |      */
24 |     public function rollback(): void
25 |     {
26 |         $this->dropIfExists("sessions");
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/tests/Console/__snapshots__/GeneratorDeepTest__test_generate_model_standard_stubs__1.txt:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Bow\Database\Migration\Migration;
 4 | use Bow\Database\Migration\SQLGenerator;
 5 | 
 6 | class FakeStandardTableMigration extends Migration
 7 | {
 8 |     /**
 9 |      * Up Migration
10 |      */
11 |     public function up(): void
12 |     {
13 |         $this->create("fakers", function (SQLGenerator $table) {
14 |             //
15 |         });
16 |     }
17 | 
18 |     /**
19 |      * Rollback migration
20 |      */
21 |     public function rollback(): void
22 |     {
23 |         $this->dropIfExists("fakers");
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/tests/Console/__snapshots__/GeneratorDeepTest__test_generate_model_stubs__1.txt:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Models;
 4 | 
 5 | use Bow\Database\Barry\Model;
 6 | 
 7 | class Example extends Model
 8 | {
 9 |     //
10 | }
11 | 


--------------------------------------------------------------------------------
/tests/Console/__snapshots__/GeneratorDeepTest__test_generate_model_table_stubs__1.txt:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Bow\Database\Migration\Migration;
 4 | use Bow\Database\Migration\SQLGenerator;
 5 | 
 6 | class FakeTableMigration extends Migration
 7 | {
 8 |     /**
 9 |      * Up Migration
10 |      */
11 |     public function up(): void
12 |     {
13 |         $this->alter("fakers", function (SQLGenerator $table) {
14 |             //
15 |         });
16 |     }
17 | 
18 |     /**
19 |      * Rollback migration
20 |      */
21 |     public function rollback(): void
22 |     {
23 |         $this->alter("fakers", function (SQLGenerator $table) {
24 |             //
25 |         });
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/tests/Console/__snapshots__/GeneratorDeepTest__test_generate_producer_stubs__1.txt:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Producers;
 4 | 
 5 | use Bow\Queue\ProducerService;
 6 | 
 7 | class FakeProducer extends ProducerService
 8 | {
 9 |     /**
10 |      * FakeProducer constructor
11 |      * 
12 |      * @return void
13 |      */
14 |     public function __construct()
15 |     {
16 |         //
17 |     }
18 | 
19 | 	/**
20 | 	 * Handle producer
21 | 	 * 
22 | 	 * @return void
23 | 	 */
24 |     public function process(): void
25 |     {
26 | 	    // Do Something
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/tests/Console/__snapshots__/GeneratorDeepTest__test_generate_queue_migration_stubs__1.txt:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Bow\Database\Migration\Migration;
 4 | use Bow\Database\Migration\Table;
 5 | 
 6 | class QueueTableMigration extends Migration
 7 | {
 8 |     /**
 9 |      * Up Migration
10 |      */
11 |     public function up(): void
12 |     {
13 |         $this->create("queues", function (Table $table) {
14 |             $table->addString('id', ["primary" => true]);
15 |             $table->addString('queue');
16 |             $table->addText('payload');
17 |             $table->addInteger('attempts', ["default" => 3]);
18 |             $table->addEnum('status', [
19 |                 "size" => ["waiting", "processing", "reserved", "failed", "done"],
20 |                 "default" => "waiting",
21 |             ]);
22 |             $table->addDatetime('available_at');
23 |             $table->addDatetime('reserved_at', ["nullable" => true, "default" => null]);
24 |             $table->addDatetime('created_at');
25 |         });
26 |     }
27 | 
28 |     /**
29 |      * Rollback migration
30 |      */
31 |     public function rollback(): void
32 |     {
33 |         $this->dropIfExists("queues");
34 | 
35 |         if ($this->getAdapterName() === 'pgsql') {
36 |             $this->addSql("DROP TYPE IF EXISTS queue_status");
37 |         }
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/tests/Console/__snapshots__/GeneratorDeepTest__test_generate_seeder_stubs__1.txt:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Faker\Factory as FakerFactory;
 4 | 
 5 | /**
 6 |  * The fakes seeder
 7 |  *
 8 |  * @see https://fakerphp.github.io for all documentation
 9 |  */
10 | $faker = FakerFactory::create();
11 | 
12 | $seed = [
13 |     'name' => $faker->name(),
14 |     'created_at' => date('Y-m-d H:i:s'),
15 |     'updated_at' => date('Y-m-d H:i:s')
16 | ];
17 | 
18 | return ['fakes' => $seed];
19 | 


--------------------------------------------------------------------------------
/tests/Console/__snapshots__/GeneratorDeepTest__test_generate_seeder_stubs__2.txt:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Faker\Factory as FakerFactory;
 4 | 
 5 | /**
 6 |  * The fakes seeder
 7 |  *
 8 |  * @see https://fakerphp.github.io for all documentation
 9 |  */
10 | $faker = FakerFactory::create();
11 | 
12 | $seed = [
13 |     'name' => $faker->name(),
14 |     'created_at' => date('Y-m-d H:i:s'),
15 |     'updated_at' => date('Y-m-d H:i:s')
16 | ];
17 | 
18 | return ['fakes' => $seed];
19 | 


--------------------------------------------------------------------------------
/tests/Console/__snapshots__/GeneratorDeepTest__test_generate_service_stubs__1.txt:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace App\Services;
4 | 
5 | class FakeService
6 | {
7 |     // Do Something
8 | }
9 | 


--------------------------------------------------------------------------------
/tests/Console/__snapshots__/GeneratorDeepTest__test_generate_session_migration_stubs__1.txt:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Bow\Database\Migration\Migration;
 4 | use Bow\Database\Migration\Table;
 5 | 
 6 | class FakeSessionMigration extends Migration
 7 | {
 8 |     /**
 9 |      * Up Migration
10 |      */
11 |     public function up(): void
12 |     {
13 |         $this->create("sessions", function (Table $table) {
14 |             $table->addColumn('id', 'string', ['primary' => true]);
15 |             $table->addColumn('time', 'timestamp');
16 |             $table->addColumn('data', 'text');
17 |             $table->addColumn('ip', 'string');
18 |         });
19 |     }
20 | 
21 |     /**
22 |      * Rollback migration
23 |      */
24 |     public function rollback(): void
25 |     {
26 |         $this->dropIfExists("sessions");
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/tests/Console/__snapshots__/GeneratorDeepTest__test_generate_standard_migration_stubs__1.txt:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Bow\Database\Migration\Migration;
 4 | use Bow\Database\Migration\Table;
 5 | 
 6 | class FakeStandardTableMigration extends Migration
 7 | {
 8 |     /**
 9 |      * Up Migration
10 |      */
11 |     public function up(): void
12 |     {
13 |         $this->create("fakers", function (Table $table) {
14 |             //
15 |         });
16 |     }
17 | 
18 |     /**
19 |      * Rollback migration
20 |      */
21 |     public function rollback(): void
22 |     {
23 |         $this->dropIfExists("fakers");
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/tests/Console/__snapshots__/GeneratorDeepTest__test_generate_table_migration_stubs__1.txt:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Bow\Database\Migration\Migration;
 4 | use Bow\Database\Migration\Table;
 5 | 
 6 | class FakeTableMigration extends Migration
 7 | {
 8 |     /**
 9 |      * Up Migration
10 |      */
11 |     public function up(): void
12 |     {
13 |         $this->alter("fakers", function (Table $table) {
14 |             //
15 |         });
16 |     }
17 | 
18 |     /**
19 |      * Rollback migration
20 |      */
21 |     public function rollback(): void
22 |     {
23 |         $this->alter("fakers", function (SQLGenerator $table) {
24 |             //
25 |         });
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/tests/Console/__snapshots__/GeneratorDeepTest__test_generate_validation_stubs__1.txt:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Validations;
 4 | 
 5 | use Bow\Validation\RequestValidation;
 6 | 
 7 | class FakeValidationRequest extends RequestValidation
 8 | {
 9 | 	/**
10 | 	 * Validation rules
11 | 	 *
12 | 	 * @return array
13 | 	 */
14 |     protected function rules(): array
15 |     {
16 | 	    return [
17 |             // Your roles here
18 |         ];
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/tests/Container/CapsuleTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Tests\Container;
 4 | 
 5 | use Bow\Container\Capsule;
 6 | use Bow\Tests\Container\Stubs\MyClass;
 7 | use StdClass;
 8 | 
 9 | class CapsuleTest extends \PHPUnit\Framework\TestCase
10 | {
11 |     /**
12 |      * @var Capsule
13 |      */
14 |     protected static Capsule $capsule;
15 | 
16 |     public static function setUpBeforeClass(): void
17 |     {
18 |         static::$capsule = new Capsule();
19 |         static::$capsule->factory('\Bow\Support\Collection', fn() => new \Bow\Support\Collection());
20 |         static::$capsule->bind('std-class', fn() => new StdClass());
21 |         static::$capsule->bind('my-class', fn(Capsule $container) => new MyClass($container['\Bow\Support\Collection']));
22 |         static::$capsule->instance("my-class-instance", new MyClass(new \Bow\Support\Collection()));
23 |     }
24 | 
25 |     public function test_make_simple_class_instance_from_container()
26 |     {
27 |         $this->assertInstanceOf(StdClass::class, static::$capsule->make('std-class'));
28 |     }
29 | 
30 |     public function test_factory()
31 |     {
32 |         $this->assertNotInstanceOf(StdClass::class, static::$capsule->make('\Bow\Support\Collection'));
33 |         $this->assertInstanceOf(\Bow\Support\Collection::class, static::$capsule->make('\Bow\Support\Collection'));
34 |     }
35 | 
36 |     public function test_make_my_class_container()
37 |     {
38 |         $my_class = static::$capsule->make('my-class');
39 | 
40 |         $this->assertInstanceOf(MyClass::class, $my_class);
41 |         $this->assertInstanceOf(\Bow\Support\Collection::class, $my_class->getCollection());
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/tests/Container/Stubs/MyClass.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Tests\Container\Stubs;
 4 | 
 5 | class MyClass
 6 | {
 7 |     private $collection;
 8 | 
 9 |     public function __construct($collection)
10 |     {
11 |         $this->collection = $collection;
12 |     }
13 | 
14 |     public function getCollection()
15 |     {
16 |         return $this->collection;
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/tests/Database/PaginationTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Bow\Tests\Database;
 6 | 
 7 | use Bow\Database\Pagination;
 8 | use PHPUnit\Framework\TestCase;
 9 | 
10 | class PaginationTest extends TestCase
11 | {
12 |     private Pagination $pagination;
13 | 
14 |     public function test_next(): void
15 |     {
16 |         $this->assertSame(2, $this->pagination->next());
17 |     }
18 | 
19 |     public function test_previous(): void
20 |     {
21 |         $this->assertSame(0, $this->pagination->previous());
22 |     }
23 | 
24 |     public function test_current(): void
25 |     {
26 |         $this->assertSame(1, $this->pagination->current());
27 |     }
28 | 
29 |     public function test_items(): void
30 |     {
31 |         $this->assertSame(['item1', 'item2', 'item3'], $this->pagination->items()->toArray());
32 |     }
33 | 
34 |     public function test_total(): void
35 |     {
36 |         $this->assertSame(3, $this->pagination->total());
37 |     }
38 | 
39 |     protected function setUp(): void
40 |     {
41 |         $this->pagination = new Pagination(
42 |             next: 2,
43 |             previous: 0,
44 |             total: 3,
45 |             perPage: 10,
46 |             current: 1,
47 |             data: collect(['item1', 'item2', 'item3'])
48 |         );
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/tests/Database/RedisTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Tests\Database;
 4 | 
 5 | use Bow\Database\Redis;
 6 | use Bow\Tests\Config\TestingConfiguration;
 7 | 
 8 | class RedisTest extends \PHPUnit\Framework\TestCase
 9 | {
10 |     public function test_create_cache()
11 |     {
12 |         $result = Redis::get('name', 'Dakia');
13 | 
14 |         $this->assertEquals($result, true);
15 |     }
16 | 
17 |     public function test_get_cache()
18 |     {
19 |         Redis::set('lastname', 'papac');
20 | 
21 |         $this->assertNull(Redis::get('name'));
22 |         $this->assertEquals(Redis::get('lastname'), "papac");
23 |     }
24 | 
25 |     protected function setUp(): void
26 |     {
27 |         parent::setUp();
28 |         $config = TestingConfiguration::getConfig();
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/tests/Database/Stubs/MigrationExtendedStub.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Tests\Database\Stubs;
 4 | 
 5 | use Bow\Database\Migration\Migration;
 6 | 
 7 | class MigrationExtendedStub extends Migration
 8 | {
 9 |     public function up(): void
10 |     {
11 |         // Empty
12 |     }
13 | 
14 |     public function rollback(): void
15 |     {
16 |         // Empty
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/tests/Database/Stubs/PetMasterModelStub.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Tests\Database\Stubs;
 4 | 
 5 | use Bow\Database\Barry\Relations\HasMany;
 6 | 
 7 | class PetMasterModelStub extends \Bow\Database\Barry\Model
 8 | {
 9 |     /**
10 |      * @var string
11 |      */
12 |     protected string $table = "pet_masters";
13 | 
14 |     /**
15 |      * @var string
16 |      */
17 |     protected string $primarey_key = 'id';
18 | 
19 |     /**
20 |      * @var bool
21 |      */
22 |     protected bool $timestamps = false;
23 | 
24 |     /**
25 |      * Get the list of pets
26 |      *
27 |      * @return HasMany
28 |      */
29 |     public function pets(): HasMany
30 |     {
31 |         return $this->hasMany(PetModelStub::class);
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/tests/Database/Stubs/PetModelStub.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Tests\Database\Stubs;
 4 | 
 5 | use Bow\Database\Barry\Relations\BelongsTo;
 6 | 
 7 | class PetModelStub extends \Bow\Database\Barry\Model
 8 | {
 9 |     /**
10 |      * @var string
11 |      */
12 |     protected string $table = "pets";
13 | 
14 |     /**
15 |      * @var string
16 |      */
17 |     protected string $primarey_key = 'id';
18 | 
19 |     /**
20 |      * @var bool
21 |      */
22 |     protected bool $timestamps = false;
23 | 
24 |     /**
25 |      * Build the relation with master class
26 |      *
27 |      * @return BelongsTo
28 |      */
29 |     public function master(): BelongsTo
30 |     {
31 |         return $this->belongsTo(PetMasterModelStub::class, "master_id");
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/tests/Database/Stubs/PetWithMasterModelStub.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Tests\Database\Stubs;
 4 | 
 5 | use Bow\Database\Barry\Relations\BelongsTo;
 6 | 
 7 | class PetWithMasterModelStub extends \Bow\Database\Barry\Model
 8 | {
 9 |     /**
10 |      * @var string
11 |      */
12 |     protected string $table = "pet_with_masters";
13 | 
14 |     /**
15 |      * @var string
16 |      */
17 |     protected string $primarey_key = 'id';
18 | 
19 |     /**
20 |      * @var bool
21 |      */
22 |     protected bool $timestamps = false;
23 | 
24 |     /**
25 |      * Build the relation with master class
26 |      *
27 |      * @return BelongsTo
28 |      */
29 |     public function master(): BelongsTo
30 |     {
31 |         return $this->belongsTo(PetMasterModelStub::class, "master_id");
32 |     }
33 | 
34 |     /**
35 |      * Build the relation with pet class
36 |      *
37 |      * @return BelongsTo
38 |      */
39 |     public function pet(): BelongsTo
40 |     {
41 |         return $this->belongsTo(PetModelStub::class, "pet_id");
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/tests/Events/Stubs/EventModelStub.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Tests\Events\Stubs;
 4 | 
 5 | use Bow\Database\Barry\Model;
 6 | 
 7 | class EventModelStub extends Model
 8 | {
 9 |     protected string $table = 'events';
10 | 
11 |     protected string $primarey_key = 'id';
12 | 
13 |     protected ?string $connection = 'mysql';
14 | 
15 |     public function __construct(array $data = [])
16 |     {
17 |         parent::__construct($data);
18 | 
19 |         $cache_filename = TESTING_RESOURCE_BASE_DIRECTORY . '/event.txt';
20 |         file_put_contents($cache_filename, '');
21 | 
22 |         EventModelStub::created(function ($event_model) use ($cache_filename) {
23 |             file_put_contents($cache_filename, 'created');
24 |         });
25 | 
26 |         EventModelStub::deleted(function ($event_model) use ($cache_filename) {
27 |             file_put_contents($cache_filename, 'deleted');
28 |         });
29 | 
30 |         EventModelStub::updated(function ($event_model) use ($cache_filename) {
31 |             file_put_contents($cache_filename, 'updated');
32 |         });
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/tests/Events/Stubs/UserEventListenerStub.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Tests\Events\Stubs;
 4 | 
 5 | use Bow\Event\Contracts\EventListener;
 6 | 
 7 | class UserEventListenerStub implements EventListener
 8 | {
 9 |     private string $cache_filename;
10 | 
11 |     public function __construct()
12 |     {
13 |         $this->cache_filename = TESTING_RESOURCE_BASE_DIRECTORY . '/event.txt';
14 |     }
15 | 
16 |     /**
17 |      * Process the event emited
18 |      *
19 |      * @param mixed $event
20 |      * @return void
21 |      */
22 |     public function process($event): void
23 |     {
24 |         file_put_contents($this->cache_filename, '');
25 |         file_put_contents($this->cache_filename, $event->getName());
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/tests/Events/Stubs/UserEventStub.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Tests\Events\Stubs;
 4 | 
 5 | use Bow\Event\Contracts\AppEvent;
 6 | use Bow\Event\Dispatchable;
 7 | 
 8 | class UserEventStub implements AppEvent
 9 | {
10 |     use Dispatchable;
11 | 
12 |     private string $name;
13 | 
14 |     public function __construct(string $name)
15 |     {
16 |         $this->name = $name;
17 |     }
18 | 
19 |     public function getName(): string
20 |     {
21 |         return $this->name;
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/tests/Filesystem/S3ServiceTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Tests\Filesystem;
 4 | 
 5 | use Bow\Storage\Service\S3Service;
 6 | use Bow\Storage\Storage;
 7 | use Bow\Tests\Config\TestingConfiguration;
 8 | 
 9 | class S3ServiceTest extends \PHPUnit\Framework\TestCase
10 | {
11 |     public static function setUpBeforeClass(): void
12 |     {
13 |         $config = TestingConfiguration::getConfig();
14 | 
15 |         Storage::configure($config["storage"]);
16 |     }
17 | 
18 |     // TODO: Make test for s3 service
19 |     public function test_instance_of_s3_service()
20 |     {
21 |         $this->markTestSkipped();
22 |         $s3 = Storage::service('s3');
23 | 
24 |         $this->assertInstanceOf(S3Service::class, $s3);
25 |     }
26 | 
27 |     public function test_put_file()
28 |     {
29 |         $this->markTestSkipped();
30 |         $s3 = Storage::service('s3');
31 | 
32 |         $result = $s3->put("my-file.txt", "Content", ['visibility' => 'public']);
33 | 
34 |         $this->assertTrue($result);
35 |     }
36 | 
37 |     public function test_get_file()
38 |     {
39 |         $this->markTestSkipped();
40 |         $s3 = Storage::service('s3');
41 | 
42 |         $content = $s3->get("my-file.txt");
43 | 
44 |         $this->assertEquals($content, 'Content');
45 |     }
46 | 
47 |     public function test_copy_file()
48 |     {
49 |         $this->markTestSkipped();
50 |         $s3 = Storage::service('s3');
51 | 
52 |         $result = $s3->copy("my-file.txt", "the-copy-file.txt");
53 |         $first_file_content = $s3->get("my-file.txt");
54 |         $second_file_content = $s3->get("the-copy-file.txt");
55 | 
56 |         $this->assertTrue($result);
57 |         $this->assertEquals($first_file_content, $second_file_content);
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------
/tests/Filesystem/TemporaryTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Tests\Filesystem;
 4 | 
 5 | use Bow\Storage\Temporary;
 6 | 
 7 | class TemporaryTest extends \PHPUnit\Framework\TestCase
 8 | {
 9 |     public function testOpenAndClose()
10 |     {
11 |         $temp = new Temporary();
12 | 
13 |         $this->assertTrue($temp->isOpen());
14 | 
15 |         $temp->close();
16 |         $this->assertFalse($temp->isOpen());
17 |     }
18 | 
19 |     public function test_write()
20 |     {
21 |         $temp = new Temporary(sys_get_temp_dir() . '/temp');
22 | 
23 |         $temp->write('hello bow');
24 | 
25 |         $this->assertEquals('hello bow', $temp->read());
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/tests/Hashing/SecurityTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Tests\Hashing;
 4 | 
 5 | use Bow\Security\Crypto;
 6 | use Bow\Security\Hash;
 7 | use Bow\Tests\Config\TestingConfiguration;
 8 | 
 9 | class SecurityTest extends \PHPUnit\Framework\TestCase
10 | {
11 |     public static function setUpBeforeClass(): void
12 |     {
13 |         TestingConfiguration::getConfig();
14 |     }
15 | 
16 |     public function test_should_decrypt_data()
17 |     {
18 |         Crypto::setkey(file_get_contents(__DIR__ . '/stubs/.key'), 'AES-256-CBC');
19 | 
20 |         $encrypted = Crypto::encrypt('bow');
21 | 
22 |         $this->assertEquals(Crypto::decrypt($encrypted), 'bow');
23 |     }
24 | 
25 |     public function test_should_check_hash_value()
26 |     {
27 |         $hashed = Hash::create('bow');
28 | 
29 |         $this->assertTrue(Hash::check('bow', $hashed));
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/tests/Hashing/stubs/.key:
--------------------------------------------------------------------------------
1 | f3G8fdrUxgud43j3MjAxNy0wNS0yMiAxNzowMjozNDE0OTU0NzI1NTQuNjkzNw==


--------------------------------------------------------------------------------
/tests/Messaging/Stubs/TestMessage.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Tests\Messaging\Stubs;
 4 | 
 5 | use Bow\Database\Barry\Model;
 6 | use Bow\Mail\Envelop;
 7 | use Bow\Messaging\Messaging;
 8 | 
 9 | class TestMessage extends Messaging
10 | {
11 |     public function channels(Model $context): array
12 |     {
13 |         return ['mail', 'database', 'slack', 'sms', 'telegram'];
14 |     }
15 | 
16 |     public function toMail(Model $context): Envelop
17 |     {
18 |         return (new Envelop())
19 |             ->to('test@example.com')
20 |             ->subject('Test Message')
21 |             ->view('email');
22 |     }
23 | 
24 |     public function toDatabase(Model $context): array
25 |     {
26 |         return [
27 |             'type' => 'test_message',
28 |             'data' => [
29 |                 'message' => 'Test message content'
30 |             ]
31 |         ];
32 |     }
33 | 
34 |     public function toSlack(Model $context): array
35 |     {
36 |         return [
37 |             'webhook_url' => 'https://hooks.slack.com/services/test',
38 |             'content' => [
39 |                 'text' => 'Test message for Slack'
40 |             ]
41 |         ];
42 |     }
43 | 
44 |     public function toSms(Model $context): array
45 |     {
46 |         return [
47 |             'to' => '+1234567890',
48 |             'message' => 'Test SMS message'
49 |         ];
50 |     }
51 | 
52 |     public function toTelegram(Model $context): array
53 |     {
54 |         return [
55 |             'chat_id' => '123456789',
56 |             'message' => 'Test Telegram message',
57 |             'parse_mode' => 'HTML'
58 |         ];
59 |     }
60 | }
61 | 


--------------------------------------------------------------------------------
/tests/Messaging/Stubs/TestNotifiableModel.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Tests\Messaging\Stubs;
 4 | 
 5 | use Bow\Database\Barry\Model;
 6 | use Bow\Messaging\CanSendMessage;
 7 | 
 8 | class TestNotifiableModel extends Model
 9 | {
10 |     use CanSendMessage;
11 | }
12 | 


--------------------------------------------------------------------------------
/tests/Queue/EventQueueTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Tests\Queue;
 4 | 
 5 | use Bow\Cache\CacheConfiguration;
 6 | use Bow\Configuration\EnvConfiguration;
 7 | use Bow\Configuration\LoggerConfiguration;
 8 | use Bow\Database\DatabaseConfiguration;
 9 | use Bow\Event\EventProducer;
10 | use Bow\Mail\MailConfiguration;
11 | use Bow\Queue\Connection;
12 | use Bow\Queue\QueueConfiguration;
13 | use Bow\Tests\Config\TestingConfiguration;
14 | use Bow\Tests\Events\Stubs\UserEventListenerStub;
15 | use Bow\Tests\Events\Stubs\UserEventStub;
16 | use Bow\View\ViewConfiguration;
17 | use PHPUnit\Framework\TestCase;
18 | 
19 | class EventQueueTest extends TestCase
20 | {
21 |     private static Connection $connection;
22 | 
23 |     public static function setUpBeforeClass(): void
24 |     {
25 |         TestingConfiguration::withConfigurations([
26 |             CacheConfiguration::class,
27 |             QueueConfiguration::class,
28 |             DatabaseConfiguration::class,
29 |             EnvConfiguration::class,
30 |             LoggerConfiguration::class,
31 |             MailConfiguration::class,
32 |             ViewConfiguration::class,
33 |         ]);
34 | 
35 |         $config = TestingConfiguration::getConfig();
36 |         $config->boot();
37 | 
38 |         static::$connection = new Connection($config["queue"]);
39 |     }
40 | 
41 |     /**
42 |      * @test
43 |      */
44 |     public function it_should_queue_event()
45 |     {
46 |         $adapter = static::$connection->setConnection("beanstalkd")->getAdapter();
47 |         $producer = new EventProducer(new UserEventListenerStub(), new UserEventStub("bowphp"));
48 |         $cache_filename = TESTING_RESOURCE_BASE_DIRECTORY . '/event.txt';
49 | 
50 |         $adapter->push($producer);
51 |         $adapter->run();
52 | 
53 |         $this->assertEquals("bowphp", file_get_contents($cache_filename));
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/tests/Queue/MailQueueTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Tests\Queue;
 4 | 
 5 | use Bow\Cache\CacheConfiguration;
 6 | use Bow\Configuration\EnvConfiguration;
 7 | use Bow\Configuration\LoggerConfiguration;
 8 | use Bow\Database\DatabaseConfiguration;
 9 | use Bow\Mail\Envelop;
10 | use Bow\Mail\MailConfiguration;
11 | use Bow\Mail\MailQueueProducer;
12 | use Bow\Queue\Connection as QueueConnection;
13 | use Bow\Queue\QueueConfiguration;
14 | use Bow\Tests\Config\TestingConfiguration;
15 | use Bow\View\ViewConfiguration;
16 | use PHPUnit\Framework\TestCase;
17 | 
18 | class MailQueueTest extends TestCase
19 | {
20 |     private static QueueConnection $connection;
21 | 
22 |     public static function setUpBeforeClass(): void
23 |     {
24 |         TestingConfiguration::withConfigurations([
25 |             CacheConfiguration::class,
26 |             QueueConfiguration::class,
27 |             DatabaseConfiguration::class,
28 |             EnvConfiguration::class,
29 |             LoggerConfiguration::class,
30 |             MailConfiguration::class,
31 |             ViewConfiguration::class,
32 |         ]);
33 |         $config = TestingConfiguration::getConfig();
34 |         $config->boot();
35 | 
36 |         static::$connection = new QueueConnection($config["queue"]);
37 |     }
38 | 
39 |     public function testQueueMail()
40 |     {
41 |         $envelop = new Envelop();
42 |         $envelop->to("bow@bow.org");
43 |         $envelop->subject("hello from bow");
44 |         $producer = new MailQueueProducer("email", [], $envelop);
45 | 
46 |         $adapter = static::$connection->setConnection("beanstalkd")->getAdapter();
47 | 
48 |         $adapter->push($producer);
49 | 
50 |         $adapter->run();
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/tests/Queue/Stubs/BasicProducerStubs.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Tests\Queue\Stubs;
 4 | 
 5 | use Bow\Queue\ProducerService;
 6 | 
 7 | class BasicProducerStubs extends ProducerService
 8 | {
 9 |     public function __construct(
10 |         private string $connection
11 |     ) {
12 |     }
13 | 
14 |     public function process(): void
15 |     {
16 |         file_put_contents(TESTING_RESOURCE_BASE_DIRECTORY . "/{$this->connection}_producer.txt", BasicProducerStubs::class);
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/tests/Queue/Stubs/MixedProducerStub.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Tests\Queue\Stubs;
 4 | 
 5 | use Bow\Queue\ProducerService;
 6 | 
 7 | class MixedProducerStub extends ProducerService
 8 | {
 9 |     public function __construct(
10 |         private ServiceStub $service,
11 |         private string $connection
12 |     ) {
13 |     }
14 | 
15 |     public function process(): void
16 |     {
17 |         $this->service->fire($this->connection);
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/tests/Queue/Stubs/ModelProducerStub.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Tests\Queue\Stubs;
 4 | 
 5 | use Bow\Queue\ProducerService;
 6 | 
 7 | class ModelProducerStub extends ProducerService
 8 | {
 9 |     public function __construct(
10 |         private PetModelStub $pet,
11 |         private string $connection
12 |     ) {
13 |         $this->pet = $pet;
14 |         $this->connection = $connection;
15 |     }
16 | 
17 |     public function process(): void
18 |     {
19 |         $this->pet->persist();
20 | 
21 |         file_put_contents(TESTING_RESOURCE_BASE_DIRECTORY . "/{$this->connection}_queue_pet_model_stub.txt", $this->pet->toJson());
22 | 
23 |         $this->deleteJob();
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/tests/Queue/Stubs/PetModelStub.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Tests\Queue\Stubs;
 4 | 
 5 | use Bow\Database\Barry\Model;
 6 | 
 7 | class PetModelStub extends Model
 8 | {
 9 |     protected string $table = 'pets';
10 | }
11 | 


--------------------------------------------------------------------------------
/tests/Queue/Stubs/ServiceStub.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Tests\Queue\Stubs;
 4 | 
 5 | class ServiceStub
 6 | {
 7 |     /**
 8 |      * The fire method
 9 |      *
10 |      * @param string $connection
11 |      * @return void
12 |      */
13 |     public function fire(string $connection): void
14 |     {
15 |         file_put_contents(TESTING_RESOURCE_BASE_DIRECTORY . "/{$connection}_producer_service.txt", ServiceStub::class);
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/tests/Support/EnvTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Tests\Support;
 4 | 
 5 | use Bow\Support\Env;
 6 | 
 7 | class EnvTest extends \PHPUnit\Framework\TestCase
 8 | {
 9 |     public static function setUpBeforeClass(): void
10 |     {
11 |         $env_filename = __DIR__ . '/stubs/env.json';
12 | 
13 |         if (!file_exists($env_filename)) {
14 |             file_put_contents($env_filename, json_encode(['APP_NAME' => 'papac']));
15 |         }
16 | 
17 |         Env::load($env_filename);
18 |     }
19 | 
20 |     public function test_is_loaded()
21 |     {
22 |         $this->assertEquals(Env::isLoaded(), true);
23 |     }
24 | 
25 |     public function test_get()
26 |     {
27 |         $this->assertEquals(Env::get('APP_NAME'), 'papac');
28 |         $this->assertNull(Env::get('LAST_NAME'));
29 |         $this->assertEquals(Env::get('SINCE', date('Y')), date('Y'));
30 |     }
31 | 
32 |     public function test_set()
33 |     {
34 |         Env::set('APP_NAME', 'bow framework');
35 | 
36 |         $this->assertNotEquals(Env::get('APP_NAME'), 'papac');
37 |         $this->assertEquals(Env::get('APP_NAME'), 'bow framework');
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/tests/Support/HttpClientTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Tests\Support;
 4 | 
 5 | use Bow\Http\Client\HttpClient;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class HttpClientTest extends TestCase
 9 | {
10 |     public function test_get_method()
11 |     {
12 |         $http = new HttpClient();
13 | 
14 |         $response = $http->get("https://www.oogle.com");
15 | 
16 |         $this->assertEquals($response->statusCode(), 503);
17 |     }
18 | 
19 |     public function test_get_method_with_custom_headers()
20 |     {
21 |         $http = new HttpClient();
22 | 
23 |         $http->addHeaders(["X-Api-Key" => "Fake-Key"]);
24 |         $response = $http->get("https://www.google.com");
25 | 
26 |         $this->assertEquals($response->statusCode(), 200);
27 |     }
28 | 
29 |     public function test_should_be_fail_with_get_method()
30 |     {
31 |         $http = new HttpClient("https://www.google.com");
32 | 
33 |         $http->addHeaders(["X-Api-Key" => "Fake-Key"]);
34 |         $response = $http->get("/the-fake-url");
35 | 
36 |         $this->assertEquals($response->statusCode(), 404);
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/tests/Support/TestingTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Tests\Support;
 4 | 
 5 | use Bow\Testing\TestCase;
 6 | 
 7 | class TestingTest extends TestCase
 8 | {
 9 |     /**
10 |      * The base url
11 |      *
12 |      * @var string
13 |      */
14 |     protected ?string $url = "https://google.com";
15 | 
16 |     public function test_get_method()
17 |     {
18 |         $response = $this->get("/");
19 | 
20 |         $response->assertStatus(200);
21 |     }
22 | 
23 |     public function test_get_method_with_custom_headers()
24 |     {
25 |         $this->withHeaders(["X-Api-Key" => "Fake-Key"]);
26 | 
27 |         $response = $this->get("/");
28 | 
29 |         $response->assertStatus(200);
30 |     }
31 | 
32 |     public function test_should_be_fail_with_get_method()
33 |     {
34 |         $this->withHeaders(["X-Api-Key" => "Fake-Key"]);
35 | 
36 |         $response = $this->get("/the-fake-url-for-my-testing-please-do-not-block-this");
37 | 
38 |         $response->assertStatus(404);
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/tests/Support/stubs/env.json:
--------------------------------------------------------------------------------
1 | {
2 |     "APP_NAME": "papac",
3 |     "API": {
4 |         "URL": "https://localhost:8000",
5 |         "KEY": "key"
6 |     }
7 | }
8 | 


--------------------------------------------------------------------------------
/tests/Translate/stubs/en/welcome.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | return [
 4 |     'message' => 'Bow framework',
 5 |     'user' => [
 6 |         'name' => 'Franck'
 7 |     ],
 8 |     'plurial' => 'User|Users',
 9 |     'hello' => 'Hello {name}'
10 | ];
11 | 


--------------------------------------------------------------------------------
/tests/Translate/stubs/fr/welcome.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | return [
 4 |     'message' => 'Bow framework',
 5 |     'user' => [
 6 |         'name' => 'Franck'
 7 |     ],
 8 |     'plurial' => 'Utilisateur|Utilisateurs',
 9 |     'hello' => 'Bonjour {name}'
10 | ];
11 | 


--------------------------------------------------------------------------------
/tests/View/ViewTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bow\Tests\View;
 4 | 
 5 | use Bow\Tests\Config\TestingConfiguration;
 6 | use Bow\View\View;
 7 | 
 8 | class ViewTest extends \PHPUnit\Framework\TestCase
 9 | {
10 |     public static function setUpBeforeClass(): void
11 |     {
12 |         $config = TestingConfiguration::getConfig();
13 | 
14 |         View::configure($config["view"]);
15 |     }
16 | 
17 |     public static function tearDownAfterClass(): void
18 |     {
19 |         foreach (glob(TESTING_RESOURCE_BASE_DIRECTORY . '/cache/*.php') as $value) {
20 |             @unlink($value);
21 |         }
22 | 
23 |         foreach (glob(TESTING_RESOURCE_BASE_DIRECTORY . '/cache/**/*.php') as $value) {
24 |             @unlink($value);
25 |             @rmdir(dirname($value));
26 |         }
27 |     }
28 | 
29 |     public function test_twig_compilation()
30 |     {
31 |         View::getInstance();
32 | 
33 |         $result = View::parse('twig', ['name' => 'bow', 'engine' => 'twig']);
34 | 
35 |         $this->assertEquals(trim($result), '<p>bow see hello world by twig</p>');
36 |     }
37 | 
38 |     public function test_tintin_compilation()
39 |     {
40 |         View::getInstance()->setEngine('tintin')->setExtension('.tintin.php');
41 | 
42 |         $result = View::parse('tintin', ['name' => 'bow', 'engine' => 'tintin']);
43 | 
44 |         $this->assertEquals(trim($result), '<p>bow see hello world by tintin</p>');
45 |     }
46 | 
47 |     public function test_php_compilation()
48 |     {
49 |         View::getInstance()->setEngine('php')->setExtension('.php');
50 | 
51 |         $result = View::parse('php', ['name' => 'bow', 'engine' => 'php']);
52 | 
53 |         $this->assertEquals(trim($result), '<p>bow see hello world by php</p>');
54 |     }
55 | 
56 |     public function test_file_exists()
57 |     {
58 |         View::getInstance()->fileExists('php');
59 | 
60 |         $this->assertTrue(View::getInstance()->fileExists('php'));
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/tests/View/stubs/404.twig:
--------------------------------------------------------------------------------
1 | Not found
2 | 


--------------------------------------------------------------------------------
/tests/View/stubs/email.twig:
--------------------------------------------------------------------------------
1 | Hello,
2 | 
3 | Bow framework is awesome
4 | 
5 | Best,
6 | 


--------------------------------------------------------------------------------
/tests/View/stubs/mail.twig:
--------------------------------------------------------------------------------
1 | Hello {{ name }}
2 | 
3 | The mail content
4 | 


--------------------------------------------------------------------------------
/tests/View/stubs/php.php:
--------------------------------------------------------------------------------
1 | <p><?php echo isset($name) ? $name : 'bow'; ?> see hello world by <?php echo isset($engine) ? $engine : 'php'; ?></p>


--------------------------------------------------------------------------------
/tests/View/stubs/tintin.tintin.php:
--------------------------------------------------------------------------------
1 | <p>{{ $name }} see hello world by {{ $engine }}</p>


--------------------------------------------------------------------------------
/tests/View/stubs/twig.twig:
--------------------------------------------------------------------------------
1 | <p>{{ name }} see hello world by {{ engine }}</p>


--------------------------------------------------------------------------------
/tests/bootstrap.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | define('TESTING_RESOURCE_BASE_DIRECTORY', sprintf('%s/bowphp_testing', sys_get_temp_dir()));
4 | 
5 | require __DIR__ . "/../vendor/autoload.php";
6 | 


--------------------------------------------------------------------------------