DEV Community: Yegor Shytikov

From Proprietary Grey Zone to Open Source: Hyvä Theme’s Licensing Journey

Yegor Shytikov — Mon, 17 Nov 2025 08:33:04 +0000

When Hyvä launched, it promised to fix everything merchants hated about Magento’s default Luma theme: heavy JS, slow Core Web Vitals, and a painful developer experience. Agencies and merchants were happy to pay for a faster, cleaner frontend.

But under the hood, there was always a big question:

Was Hyvä truly a “from scratch” frontend — or a commercial fork of Magento Open Source distributed under a restrictive license?

Now that Hyvä Theme has been relicensed as free and open source under OSL 3.0 + AFL 3.0, the answer matters less for the future and more as a lesson in how not to mix copyleft and proprietary licensing.

This article walks through that journey.

Note: This is a technical and licensing opinion piece, not a legal judgment. No public court decision has declared Hyvä in violation of Magento’s license. The analysis here explains why many in the community perceived a grey zone, and how open-sourcing the theme addresses it.

The Promise: “Built from Scratch” and Commercial Licensing

Hyvä marketed itself as a frontend “built from scratch” on top of Magento, with:
• A minimal, Tailwind-based CSS stack,
• Alpine.js replacing Magento’s heavy RequireJS/Knockout system,
• Dramatically improved performance scores.

This frontend was sold under a proprietary license, with a four-figure one-time fee per project and strict usage terms.

For many agencies, that seemed fair: pay once, get a faster Magento.

The problem only appears when you look at the actual code.

The Reality: Massive Magento Code Reuse Under the Hood

Once Hyvä’s repositories became public, a detailed code review showed that large portions of the theme were:
• Copied Magento core templates dropped into Magento_* module directories,
• Templates that were almost identical to Magento’s originals, with:
• extra inline JavaScript,
• small structural or markup tweaks, ViewModels and service classes largely mirroring Magento’s own logic.

In other words, Hyvä wasn’t just a lightweight set of overrides or a pure headless frontend. It looked very much like a fork / derivative work of Magento’s own frontend stack.

Architecturally, that led to a long list of technical problems you’ve already documented:
• Huge inline scripts in .phtml,
* Global state and REST calls inside templates,
• Hard-to-extend monolithic views,
• Fragile upgrade paths that require manual diffing against Magento core.

But our focus here is licensing, not architecture.

3. Why This Clashed With OSL 3.0 in the Eyes of Many

Magento’s OSL 3.0 license allows:
• Copying and modifying core code,
• Selling products that include that code.

However, it demands that if you redistribute modified core files, you must:
• Keep Magento’s original license notices, and
• License the derivative under OSL 3.0 (or compatible terms), not a more restrictive proprietary license.

So when critics saw:
• Magento templates copied into Hyvä’s theme,
• Magento attributions seemingly removed or replaced,
• The whole bundle sold under a commercial “Hyvä Software User License” with no source access,

it looked like a classic copyleft conflict.

Again, this doesn’t automatically mean a court would find actual infringement. But from a risk and compliance standpoint, it’s clear why people started asking:
• “Is it even safe for us, as merchants, to pay for this?”
• “If Adobe or another rights holder enforced OSL 3.0 strictly, what would happen?”
• “Why not just open-source the parts that are obviously derived from Magento?”

Those questions culminated in multiple public posts and discussions calling on Hyvä to open-source its Magento-derived code to respect OSL 3.0.

4. The Turning Point: Hyvä Goes Open Source (OSL 3.0 + AFL 3.0)

In early November 2025, Hyvä announced that:
• The Hyvä Theme core is now free and open source.
• The code is relicensed under OSL 3.0 + AFL 3.0 – the same licenses Magento uses.
• Supporting theme modules are also relicensed under OSL 3.0.
• The business model shifts to selling:
• Hyvä UI as a separate paid component,
• Hyvä Checkout, Enterprise, and Commerce as proprietary add-ons.

This change does three important things from a licensing perspective:
1. Aligns the theme code with Magento’s licensing model
Hyvä’s code that builds directly on Magento’s frontend stack now shares the same copyleft obligations.
2. Removes the closed-source barrier
Developers, auditors, and merchants can inspect the actual files, check attributions, and verify compliance themselves.
3. Lowers risk for new adopters
Anyone implementing Hyvä today is using a theme which, at least on paper, respects OSL 3.0’s copyleft requirements.

Whether this change was driven primarily by:
• long-term business strategy,
• community and ecosystem pressure,
• or a quiet recognition that the previous license posture was hard to justify,

is something only Hyvä’s leadership can answer. Official messaging emphasizes community and strategic growth.

But from the outside, the effect is clear: the licensing grey zone around the theme core has largely been closed.

5. What Still Deserves Scrutiny

Even with the theme now open source, a few areas still deserve attention:
• Historical closed-source releases
Past distributions that may have contained Magento-derived code under a proprietary license don’t magically disappear. For most merchants, though, risk is low if they move to the current open-source base.
• Enterprise / paid products
Hyvä Commerce / Enterprise may also interact with or wrap Magento code. Ensuring that any Magento-derived parts in those products comply with their respective licenses will be important.
• Attribution and headers
Now that the repository is public, it’s easier to spot where Magento code is reused, and whether Magento’s original notices are preserved as required by OSL 3.0.

The good news: because the theme is open, the community can help keep everyone honest.

6. Takeaways for Developers, Vendors, and Merchants

For frontend vendors and theme authors:
• If your product is effectively a fork of an open-source platform, you must treat licensing as a first-class architectural constraint.
• “Copy and paste core, close it, and sell it” is rarely compatible with copyleft licenses like OSL 3.0.
• Open-sourcing the parts that are clearly derivative often isn’t optional — it’s simply what the license demands.

For merchants and agencies:
• Don’t just look at performance benchmarks and marketing claims; ask:
• “What is this based on?”
• “What licenses apply?”
• “Is this code legally clean to use at scale?”
• Hyvä’s move to OSL 3.0 / AFL 3.0 is a net win: it reduces legal uncertainty, improves transparency, and gives you an audit-able codebase.

For the Magento ecosystem as a whole:
• This saga shows that community scrutiny works. Questions about license compliance, raised publicly and persistently, can push popular vendors toward more open and compliant models.
• At the same time, it’s a cautionary tale: if you build a closed product on top of copyleft code, you should expect people to notice — and eventually, you may have to open the doors anyway.

Magento 2 ARM Ubuntu Server 24.04 AMD installation sh script

Yegor Shytikov — Wed, 16 Oct 2024 23:55:33 +0000

Two years ago, I was the first person who researched Magento performance and installation on ARM Graviton(AWS) and Amper(Oracle) servers. However, since then, AWS and Linux have improved support ARM graviton architecture and support. Previously, there was an issue with the same software support from the Linux repos, and you need to install it from the sources. Now, you can install everything from the default Ubuntu repo.

I wrote a new performance and installation script for the Graviton 4 C8g AWS instance.

The new AWS Ubuntu image has better support for ARM compiler software from the default repository.

So here is the Magento C8g Ubuntu Server 24 instance installation script:
https://github.com/Genaker/Magento-Linux-Installation/blob/master/magento2-ubuntu24-arm-installation.sh

Magento 2 Installation Steps:

Nginx Config
Setup NGINX
Setup PHP
Configure PHP
Configure Opcache
Setup MySQL 8
Setup OpenSearch/ElasticSearch
Setup Redis
Setup Composer
Setup Magento from the composer
Set Nginx Config
Set Folder Permissions

Just run this script as user data or manually, and you will have the magento ubuntu 24 server up and running.

`
MAGE_URL="ec2-98-81-130-207.compute-1.amazonaws.com"
PHP_VERSION="8.1"
OPENSEARCH_VERSION="2.11.1"

magento2conf="upstream fastcgi_backend {
server unix:/run/php/php$PHP_VERSION-fpm.sock;
}

server {
listen 80;
server_name $MAGE_URL;
set \$MAGE_ROOT /var/www/html/magento;
include /var/www/html/magento/nginx.conf.sample;
}"

sudo apt-get update

Setup NGINX

sudo apt install nginx -y
sudo systemctl start nginx
sudo systemctl enable nginx
sudo apt install unzip -y

Setup PHP

sudo apt install -y software-properties-common
yes | sudo add-apt-repository ppa:ondrej/php
sudo apt-get install php$PHP_VERSION php$PHP_VERSION-dev php$PHP_VERSION-fpm php$PHP_VERSION-bcmath php$PHP_VERSION-intl php$PHP_VERSION-soap php$PHP_VERSION-zip php$PHP_VERSION-curl php$PHP_VERSION-mbstring php$PHP_VERSION-mysql php$PHP_VERSION-gd php$PHP_VERSION-xml --no-install-recommends -y
php -v

Configure PHP

sudo sed -i 's/^(max_execution_time = )[0-9]/\17200/' /etc/php/$PHP_VERSION/fpm/php.ini
sudo sed -i 's/^(max_input_time = )[0-9]/\17200/' /etc/php/$PHP_VERSION/fpm/php.ini
sudo sed -i 's/^(memory_limit = )[0-9]*M/\12048M/' /etc/php/$PHP_VERSION/fpm/php.ini
sudo sed -i 's/^(post_max_size = )[0-9]*M/\164M/' /etc/php/$PHP_VERSION/fpm/php.ini
sudo sed -i 's/^(upload_max_filesize = )[0-9]*M/\164M/' /etc/php/$PHP_VERSION/fpm/php.ini
sudo sed -i 's/expose_php = On/expose_php = Off/' /etc/php/$PHP_VERSION/fpm/php.ini
sudo sed -i 's/;realpath_cache_size = 16k/realpath_cache_size = 512k/' /etc/php/$PHP_VERSION/fpm/php.ini
sudo sed -i 's/;realpath_cache_ttl = 120/realpath_cache_ttl = 86400/' /etc/php/$PHP_VERSION/fpm/php.ini
sudo sed -i 's/short_open_tag = Off/short_open_tag = On/' /etc/php/$PHP_VERSION/fpm/php.ini
sudo sed -i 's/;max_input_vars = 1000/max_input_vars = 50000/' /etc/php/$PHP_VERSION/fpm/php.ini
sudo sed -i 's/session.gc_maxlifetime = 1440/session.gc_maxlifetime = 28800/' /etc/php/$PHP_VERSION/fpm/php.ini
sudo sed -i 's/mysql.allow_persistent = On/mysql.allow_persistent = Off/' /etc/php/$PHP_VERSION/fpm/php.ini
sudo sed -i 's/mysqli.allow_persistent = On/mysqli.allow_persistent = Off/' /etc/php/$PHP_VERSION/fpm/php.ini

Configure Opcache

sudo bash -c "cat > /etc/php/$PHP_VERSION/fpm/conf.d/10-opcache.ini <<END
zend_extension=opcache.so
opcache.enable = 1
opcache.enable_cli = 0
opcache.memory_consumption = 356
opcache.interned_strings_buffer = 4
opcache.max_accelerated_files = 100000
opcache.max_wasted_percentage = 15
opcache.use_cwd = 1
opcache.validate_timestamps = 0
;opcache.revalidate_freq = 2
;opcache.validate_permission= 1
;opcache.validate_root= 1
opcache.file_update_protection = 2
opcache.revalidate_path = 0
opcache.save_comments = 1
opcache.load_comments = 1
opcache.fast_shutdown = 1
opcache.enable_file_override = 0
opcache.optimization_level = 0xffffffff
opcache.inherited_hack = 1
opcache.max_file_size = 0
opcache.consistency_checks = 0
opcache.force_restart_timeout = 60
opcache.log_verbosity_level = 1
opcache.protect_memory = 0
END"

sudo systemctl start php$PHP_VERSION-fpm.service
sudo systemctl enable php$PHP_VERSION-fpm.service
sudo systemctl status php$PHP_VERSION-fpm.service --no-pager
sudo systemctl restart php$PHP_VERSION-fpm.service

Setup MySQL

sudo apt install mysql-server -y
sudo systemctl start mysql
sudo systemctl enable mysql
sudo mysql -e "CREATE DATABASE magento; CREATE USER 'magento'@'localhost' IDENTIFIED BY 'magento'; GRANT ALL ON magento.* TO 'magento'@'localhost'; FLUSH PRIVILEGES;"
sudo mysql -e "show databases"
sudo mysql -e "SET GLOBAL log_bin_trust_function_creators = 1;"
sudo mysql -e "select version()"

Setup OpenSearch

curl -o- https://artifacts.opensearch.org/publickeys/opensearch.pgp | sudo gpg --dearmor --batch --yes -o /usr/share/keyrings/opensearch-keyring
echo "deb [signed-by=/usr/share/keyrings/opensearch-keyring] https://artifacts.opensearch.org/releases/bundle/opensearch/2.x/apt stable main" | sudo tee /etc/apt/sources.list.d/opensearch-2.x.list
sudo apt update
sudo apt list -a opensearch
sudo apt install opensearch=$OPENSEARCH_VERSION

apt purge opensearch -y

sudo bash -c "echo \"plugins.security.disabled: true\" >> /etc/opensearch/opensearch.yml"
sudo cat /etc/opensearch/opensearch.yml
sudo systemctl enable --now opensearch
sudo systemctl restart opensearch
sudo systemctl status opensearch

logs : cat /etc/opensearch/opensearch.yml

curl -X GET localhost:9200

Setup Redis

sudo apt install redis -y
sudo systemctl restart redis.service
sudo systemctl status redis

Setup Composer

curl -sS https://getcomposer.org/installer -o composer-setup.php
sudo php composer-setup.php --install-dir=/usr/local/bin --filename=composer
composer -V

sudo mkdir /var/www/html/magento
sudo chmod -R 755 /var/www/html/magento/

composer config --global http-basic.repo.magento.com 5310458a34d580de1700dfe826ff19a1 255059b03eb9d30604d5ef52fca7465d
composer create-project --repository-url=https://repo.magento.com/ magento/project-community-edition /var/www/html/magento

cd /var/www/html/magento/

bin/magento setup:install --base-url=http://$MAGE_URL --db-host=localhost --db-name=magento --db-user=magento --db-password=magento --admin-firstname=Magento --admin-lastname=Admin --admin-email=admin@yourdomain.com --admin-user=admin --admin-password=admin123 --language=en_US --currency=USD --timezone=America/Chicago --use-rewrites=1 --search-engine=opensearch

yes | /var/www/html/magento/bin/magento setup:config:set --cache-backend=redis --cache-backend-redis-server=127.0.0.1 --cache-backend-redis-db=0
yes | /var/www/html/magento/bin/magento setup:config:set --page-cache=redis --page-cache-redis-server=127.0.0.1 --page-cache-redis-db=1
yes | /var/www/html/magento/bin/magento setup:config:set --session-save=redis --session-save-redis-host=127.0.0.1 --session-save-redis-log-level=4 --session-save-redis-db=2

php bin/magento module:disable Magento_AdminAdobeImsTwoFactorAuth
php bin/magento module:disable Magento_TwoFactorAuth

sudo bash -c "echo '$magento2conf' > /etc/nginx/conf.d/magento.conf"
sudo nginx -t
sudo service nginx restart

sudo chmod -R 777 /var/www/html/magento/*

curl http://$MAGE_URL

tail -n 20 /var/log/nginx/error.log

sudo chown -R www-data:www-data /var/www/html/magento
sudo find var generated vendor pub/static pub/media app/etc -type f -exec chmod g+w {} +
`

Magento 2 ARM Performance

AWS C5.large has 0.032 PHP performance score (less is better). Cli Performace 0.110ms
AWS C8.xlarge has 0.029 PHP performance score (less is better), CLI performace is: 0.066 for Cli opcache doesn't work. It is well known PHP issue.

So, Graviton 4 instances have ~20% greater PHP performance score, especially for corn operations.

More about Magento 2 PHP performance test here:

https://github.com/Genaker/Magento2OPcacheGUI

C8g instances offer up to 30% better performance and larger instance sizes with up to 3x more vCPUs and memory than the seventh-generation AWS Graviton3-based C7g instances.

The cost of the ARM Graviton 4 C8g.48xlarge with 192 physical (it is twice more than Intel with 192 virtual CPUs. You can count it as 384 CPUs) CPUs is $ 5,000 per month. It can handle any load as a web server. It will handle approximately 200 uncached requests per second without any issues. But you can scale it down and reduce the cost. For example, if you need only 20 uncached requests per second, you can pay 500$ per month for the C8g.4xlarge (16CPUs) computed resources and you can also apply AWS cost savings.

Magento 2 get Configured Used Children Product Collection

Yegor Shytikov — Fri, 28 Jan 2022 23:10:35 +0000

/**
* Returns array of sub-products for specified configurable product
* Result array contains all children for specified configurable product
*
* @param \Magento\Catalog\Model\Product $product
* @param array $requiredAttributeIds Attributes to include in the select; one-dimensional array
* @return ProductInterface[]
*/
public function getUsedProducts($product, $requiredAttributeIds = null)
{
if (!$product->hasData($this->_usedProducts)) {
$collection = $this->getConfiguredUsedProductCollection($product, false, $requiredAttributeIds);
$usedProducts = array_values($collection->getItems());
$product->setData($this->_usedProducts, $usedProducts);
}

    return $product->getData($this->_usedProducts);
}

AWS Amazon Linux 2 amazon-linux-extras PHP version upgrade 7.2 to 7.4 +

Yegor Shytikov — Thu, 01 Jul 2021 16:06:05 +0000

sudo yum remove php*

or 'sudo yum autoremove php php-common' this one not tested

sudo amazon-linux-extras disable php7.2
sudo amazon-linux-extras enabmle php7.4
yum clean metadata

sudo yum -y install php php-common php-mysqlnd php-opcache php-xml php-gd php-soap php-bcmath php-intl php-mbstring php-json php-iconv php-fpm php-apcu php-zip php-devel

Magento {\"error\":{\"root_cause\"[{\"type\":\"index_not_found_exception\",\"reason\":\"no such index\":

Yegor Shytikov — Fri, 14 May 2021 16:14:48 +0000

To fix this error you need to reindex bin/magento indexer:reindex

{"0":"{\"error\":{\"root_cause\":[{\"type\":\"index_not_found_exception\",\"reason\":\"no such index\",\"resource.type\":\"index_or_alias\",\"resource.id\":\"magento2_product_2\",\"index_uuid\":\"na\",\"index\":\"magento2_product_2\"}],\"type\":\"index_not_found_exception\",\"reason\":\"no such index\",\"resource.type\":\"index_or_alias\",\"resource.id\":\"magento2_product_2\",\"index_uuid\":\"na\",\"index\":\"magento2_product_2\"},\"status\":404}","1":"#1 Elasticsearch\Connections\Connection->Elasticsearch\Connections\{closure}() called at [vendor\/react\/promise\/src\/FulfilledPromise.php:28]\n#2 React\Promise\FulfilledPromise->then() called at [vendor\/ezimuel\/ringphp\/src\/Future\/CompletedFutureValue.php:55]\n#3 GuzzleHttp\Ring\Future\CompletedFutureValue->then() called at [vendor\/ezimuel\/ringphp\/src\/Core.php:341]\n#4 GuzzleHttp\Ring\Core::proxy() called at [vendor\/elasticsearch\/elasticsearch\/src\/Elasticsearch\/Connections\/Connection.php:329]\n#5 Elasticsearch\Connections\Connection->Elasticsearch\Connections\{closure}() called at [vendor\/elasticsearch\/elasticsearch\/src\/Elasticsearch\/Connections\/Connection.php:227]\n#6 Elasticsearch\Connections\Connection->performRequest() called at [vendor\/elasticsearch\/elasticsearch\/src\/Elasticsearch\/Transport.php:105]\n#7 Elasticsearch\Transport->performRequest() called at [vendor\/elasticsearch\/elasticsearch\/src\/Elasticsearch\/Client.php:1559]\n#8 Elasticsearch\Client->performRequest() called at [vendor\/elasticsearch\/elasticsearch\/src\/Elasticsearch\/Client.php:1192]\n#9 Elasticsearch\Client->search() called at [vendor\/magento\/module-elasticsearch-7\/Model\/Client\/Elasticsearch.php:367]\n#10 Magento\Elasticsearch7\Model\Client\Elasticsearch->query() called at [vendor\/magento\/module-elasticsearch\/SearchAdapter\/Dynamic\/DataProvider.php:221]\n#11 Magento\Elasticsearch\SearchAdapter\Dynamic\DataProvider->getAggregation() called at [vendor\/magento\/framework\/Search\/Dynamic\/Algorithm\/Manual.php:48]\n#12 Magento\Framework\Search\Dynamic\Algorithm\Manual->getItems() called at [vendor\/magento\/module-elasticsearch\/SearchAdapter\/Aggregation\/Builder\/Dynamic.php:48]\n#13 Magento\Elasticsearch\SearchAdapter\Aggregation\Builder\Dynamic->build()

Magento 2: SQLSTATE[HY000]: General error: 1449 The user specified as a definer ('user'@'localhost') does not exist, query was

Yegor Shytikov — Tue, 27 Apr 2021 01:21:41 +0000

grant all on *.* to 'theuser123'@'%' identified by 'Magento@1234567' with grant option;

SQLSTATE[HY000] Fixed ...

This happens after moving the DB from one server to another server. Initially, the definer was using localhost and the theuser123. On the new server, we don't have that user(theuser123), and the host had also can be changed.

Magento 2 (Zend_Db_Statement_Exception): SQLSTATE[HY000]: General error: 1449 The user specified as a definer ('theuser123'@'localhost') does not exist, query was: SELECT

Warning: session_start(): Session data file is not created by your uid in

Yegor Shytikov — Sun, 25 Apr 2021 23:04:57 +0000

PHP requires a session file to be owned by the user running PHP.

Then just run chown -R www-data:www-data /var/www/storage/session/ to own session folder and files by your PHP user (www-data:www-data are your PHP user and group separated by :).

sudo chown -R www-data:www-data /var/lib/php/session
or
sudo chown -R apache:apache /var/lib/php/session

Login and SSH to Magento Cloud

Yegor Shytikov — Thu, 22 Apr 2021 08:22:53 +0000

Install the magento-cloud CLI.

curl -sS https://accounts.magento.cloud/cli/installer | PHP

Add magento-cloud CLI to the bash profile.

export PATH=$PATH:$HOME/.magento-cloud/bin

Consult operating system documentation for details.

Reload the updated bash profile.

. ~/.bash_profile

To initiate the CLI, call magento-cloud and enter your Cloud account credentials when prompted.

Run:

magento-cloud login

SSH

magento-cloud ssh

Migrate Magento code to another server

Yegor Shytikov — Mon, 12 Apr 2021 00:24:51 +0000

SSH to both servers old one (server A) and a new one (server B)

you need to Copy the files legacy server A :

Archive it first

tar -czvf magento.tar.gz app/code/

move to the public dir server A:

 mv magento.tar.gz pub/

Go to new server B web dir. for example :

cd /var/www/html/

Download files to the new server B:

wget https://www.{domain}.com/magento.tar.gz

Untar files on a new serve B:

tar -xzvf magento.tar.gz -C magento

remove a file on the old server B:

rm pub/magento.tar.gz

In the next step, you will need to dump Magento DB. See my other posts.

Magento 2 Configurable products slow. Fix Magento performance issue

Yegor Shytikov — Tue, 23 Mar 2021 07:37:56 +0000

Magento 2 configurable products are just containers for simple products (variations). You can no longer configure pricing data directly in the configurable product as the parent configurable inherits all its unit, tier price, and inventory data from the child simple products. So on the configurable product page, Magento loads all the configurations as a simple product. Even a single Magento Product model is slow 300ms to load, what to tell about several products on the same page... The complexity of the configurable products is just terrible. Product with 5 color and 5 sizes it is 5 * 5 + 1 separate SKUs.

Magento 2 Configurable Products are slow to Load!

One of the biggest issues of the Magento 2 is the configurable products. Even Small configurable products can be slow to load in the frontend. I worked on a store with a product that is available in over 50 colors and 10 sizes. This resulted in a configurable product with over 500 child products. Due to Magento 2, Architectural issues products can lead to very slow and takes several minutes to load.

In the frontend, Magento 2 loads all variations in a giant JSON object and renders that into the DOM using the legacy Knockout JS library and Jquery. This JSON object is 1 megabyte for 1000 variations. In the backend, this JSON is also built and passed to a UI component wrapped in XML. Purely written Magento 2 Core PHP code is not able to append extremely large XML structures to an existing XML structure.

Even with 1000 variations page load time for an uncached configurable product was in excess of 60 seconds.

If you are having traffic on your site configurable products will just kill your MySQL database

Fix Magento Configurable Product Performance issue:

Unfortunately, this issue can't be fixed because even simple product is slow in the M2. It is just a waste of money and time to fix a jank car.

Laravel: Force to use HTTPS for URL with Cloudflare Flexible SSL

Yegor Shytikov — Mon, 08 Mar 2021 18:36:58 +0000

When are you using Cloudflare Flexible SSL you need a solution so that all URL on our website (created by URL, route function) must be HTTPS even though our server currently doesn't support SSL.

Solution:

Edit App\Providers\AppServiceProvider.php in the boot() method

public function boot()
{
        // custom for cloudflase flexible ssl
        if($this->checkHTTPSStatus()){
            URL::forceScheme('https');
        }
    /*...some other code...*/
}

private function checkHTTPSStatus()
{
/Select code in an option below/
}

Option 1: Switch to https according to the configuration in the env file

private function checkHTTPSStatus()
{
return env('APP_HTTPS',false) === true;
}

In .env file you must to declare APP_HTTPS parameter

APP_HTTPS=true


Option 2: Automatically switch to https if the user comes from Cloudflare Flexible SSL

private function checkHTTPSStatus()
{
return (isset($_SERVER['HTTP_X_FORWARDED_PROTO'])&&$_SERVER['HTTP_X_FORWARDED_PROTO']==='https');
}

Option 3: Full SSL

private function checkHTTPSStatus()
{
return !empty($_SERVER['HTTPS']);
}

Git Show the last files committed

Yegor Shytikov — Tue, 23 Feb 2021 08:34:47 +0000

git show --stat --oneline HEAD

Then reset the unwanted files in order to leave them out from the commit:

 git reset --soft HEAD~1

git add again

git commit -m "new commit"

git push