feature #51847 [AssetMapper] Allowing for files to be written to some non-local location (weaverryan)

This PR was squashed before being merged into the 6.4 branch.

Discussion
----------

[AssetMapper] Allowing for files to be written to some non-local location

| Q             | A
| ------------- | ---
| Branch?       | 6.4
| Bug fix?      | no
| New feature?  | yes
| Deprecations? | no
| Tickets       | Fix #50221
| License       | MIT

Hi!

An attempt at making AssetMapper flexible enough to support non-local filesystems. The "hook point" would be that you could replace the `asset_mapper.local_public_assets_filesystem` service with your own that implements `PublicAssetsFilesystemInterface`. I'm not worried about making the hook point *super* user-friendly: I just want the system to support this now, as trying to add this later (when we need to protect BC) will be harder.

Cheers!

Commits
-------

48a2d689e6e [AssetMapper] Allowing for files to be written to some non-local location

Author: fabpot

AssetMapper.php

@@ -12,7 +12,6 @@
 namespace Symfony\Component\AssetMapper;
 
 use Symfony\Component\AssetMapper\Factory\MappedAssetFactoryInterface;
-use Symfony\Component\AssetMapper\Path\PublicAssetsPathResolverInterface;
 
 /**
  * Finds and returns assets in the pipeline.
@@ -28,7 +27,7 @@ class AssetMapper implements AssetMapperInterface
     public function __construct(
         private readonly AssetMapperRepository $mapperRepository,
         private readonly MappedAssetFactoryInterface $mappedAssetFactory,
-        private readonly PublicAssetsPathResolverInterface $assetsPathResolver,
+        private readonly CompiledAssetMapperConfigReader $compiledConfigReader,
     ) {
     }
 
@@ -78,12 +77,10 @@ public function getPublicPath(string $logicalPath): ?string
     private function loadManifest(): array
     {
         if (null === $this->manifestData) {
-            $path = $this->assetsPathResolver->getPublicFilesystemPath().'/'.self::MANIFEST_FILE_NAME;
-
-            if (!is_file($path)) {
+            if (!$this->compiledConfigReader->configExists(self::MANIFEST_FILE_NAME)) {
                 $this->manifestData = [];
             } else {
-                $this->manifestData = json_decode(file_get_contents($path), true);
+                $this->manifestData = $this->compiledConfigReader->loadConfig(self::MANIFEST_FILE_NAME);
             }
         }
 

Command/AssetMapperCompileCommand.php

@@ -13,16 +13,15 @@
 
 use Symfony\Component\AssetMapper\AssetMapper;
 use Symfony\Component\AssetMapper\AssetMapperInterface;
+use Symfony\Component\AssetMapper\CompiledAssetMapperConfigReader;
 use Symfony\Component\AssetMapper\Event\PreAssetsCompileEvent;
 use Symfony\Component\AssetMapper\ImportMap\ImportMapGenerator;
-use Symfony\Component\AssetMapper\Path\PublicAssetsPathResolverInterface;
+use Symfony\Component\AssetMapper\Path\PublicAssetsFilesystemInterface;
 use Symfony\Component\Console\Attribute\AsCommand;
 use Symfony\Component\Console\Command\Command;
-use Symfony\Component\Console\Exception\InvalidArgumentException;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Output\OutputInterface;
 use Symfony\Component\Console\Style\SymfonyStyle;
-use Symfony\Component\Filesystem\Filesystem;
 use Symfony\Contracts\EventDispatcher\EventDispatcherInterface;
 
 /**
@@ -36,12 +35,11 @@
 final class AssetMapperCompileCommand extends Command
 {
     public function __construct(
-        private readonly PublicAssetsPathResolverInterface $publicAssetsPathResolver,
+        private readonly CompiledAssetMapperConfigReader $compiledConfigReader,
         private readonly AssetMapperInterface $assetMapper,
         private readonly ImportMapGenerator $importMapGenerator,
-        private readonly Filesystem $filesystem,
+        private readonly PublicAssetsFilesystemInterface $assetsFilesystem,
         private readonly string $projectDir,
-        private readonly string $publicDirName,
         private readonly bool $isDebug,
         private readonly ?EventDispatcherInterface $eventDispatcher = null,
     ) {
@@ -51,7 +49,6 @@ public function __construct(
     protected function configure(): void
     {
         $this
-            ->addOption('clean', null, null, 'Whether to clean the public directory before compiling assets')
             ->setHelp(<<<'EOT'
 The <info>%command.name%</info> command compiles and dumps all the assets in
 the asset mapper into the final public directory (usually <comment>public/assets</comment>).
@@ -64,61 +61,36 @@ protected function configure(): void
     protected function execute(InputInterface $input, OutputInterface $output): int
     {
         $io = new SymfonyStyle($input, $output);
-        $publicDir = $this->projectDir.'/'.$this->publicDirName;
-        if (!is_dir($publicDir)) {
-            throw new InvalidArgumentException(sprintf('The public directory "%s" does not exist.', $publicDir));
-        }
-
-        $outputDir = $this->publicAssetsPathResolver->getPublicFilesystemPath();
-        if ($input->getOption('clean')) {
-            $io->comment(sprintf('Cleaning <info>%s</info>', $outputDir));
-            $this->filesystem->remove($outputDir);
-            $this->filesystem->mkdir($outputDir);
-        }
-
-        // set up the file paths
-        $files = [];
-        $manifestPath = $outputDir.'/'.AssetMapper::MANIFEST_FILE_NAME;
-        $files[] = $manifestPath;
 
-        $importMapPath = $outputDir.'/'.ImportMapGenerator::IMPORT_MAP_CACHE_FILENAME;
-        $files[] = $importMapPath;
+        $this->eventDispatcher?->dispatch(new PreAssetsCompileEvent($output));
 
-        $entrypointFilePaths = [];
+        // remove existing config files
+        $this->compiledConfigReader->removeConfig(AssetMapper::MANIFEST_FILE_NAME);
+        $this->compiledConfigReader->removeConfig(ImportMapGenerator::IMPORT_MAP_CACHE_FILENAME);
+        $entrypointFiles = [];
         foreach ($this->importMapGenerator->getEntrypointNames() as $entrypointName) {
-            $dumpedEntrypointPath = $outputDir.'/'.sprintf(ImportMapGenerator::ENTRYPOINT_CACHE_FILENAME_PATTERN, $entrypointName);
-            $files[] = $dumpedEntrypointPath;
-            $entrypointFilePaths[$entrypointName] = $dumpedEntrypointPath;
+            $path = sprintf(ImportMapGenerator::ENTRYPOINT_CACHE_FILENAME_PATTERN, $entrypointName);
+            $this->compiledConfigReader->removeConfig($path);
+            $entrypointFiles[$entrypointName] = $path;
         }
 
-        // remove existing files
-        foreach ($files as $file) {
-            if (is_file($file)) {
-                $this->filesystem->remove($file);
-            }
-        }
-
-        $this->eventDispatcher?->dispatch(new PreAssetsCompileEvent($outputDir, $output));
-
-        // dump new files
-        $manifest = $this->createManifestAndWriteFiles($io, $publicDir);
-        $this->filesystem->dumpFile($manifestPath, json_encode($manifest, \JSON_PRETTY_PRINT));
+        $manifest = $this->createManifestAndWriteFiles($io);
+        $manifestPath = $this->compiledConfigReader->saveConfig(AssetMapper::MANIFEST_FILE_NAME, $manifest);
         $io->comment(sprintf('Manifest written to <info>%s</info>', $this->shortenPath($manifestPath)));
 
-        $this->filesystem->dumpFile($importMapPath, json_encode($this->importMapGenerator->getRawImportMapData(), \JSON_THROW_ON_ERROR | \JSON_PRETTY_PRINT | \JSON_UNESCAPED_SLASHES | \JSON_HEX_TAG));
+        $importMapPath = $this->compiledConfigReader->saveConfig(ImportMapGenerator::IMPORT_MAP_CACHE_FILENAME, $this->importMapGenerator->getRawImportMapData());
         $io->comment(sprintf('Import map data written to <info>%s</info>.', $this->shortenPath($importMapPath)));
 
-        $entrypointNames = $this->importMapGenerator->getEntrypointNames();
-        foreach ($entrypointFilePaths as $entrypointName => $path) {
-            $this->filesystem->dumpFile($path, json_encode($this->importMapGenerator->findEagerEntrypointImports($entrypointName), \JSON_THROW_ON_ERROR | \JSON_PRETTY_PRINT | \JSON_UNESCAPED_SLASHES | \JSON_HEX_TAG));
+        foreach ($entrypointFiles as $entrypointName => $path) {
+            $this->compiledConfigReader->saveConfig($path, $this->importMapGenerator->findEagerEntrypointImports($entrypointName));
         }
-        $styledEntrypointNames = array_map(fn (string $entrypointName) => sprintf('<info>%s</>', $entrypointName), $entrypointNames);
-        $io->comment(sprintf('Entrypoint metadata written for <comment>%d</> entrypoints (%s).', \count($entrypointNames), implode(', ', $styledEntrypointNames)));
+        $styledEntrypointNames = array_map(fn (string $entrypointName) => sprintf('<info>%s</>', $entrypointName), array_keys($entrypointFiles));
+        $io->comment(sprintf('Entrypoint metadata written for <comment>%d</> entrypoints (%s).', \count($entrypointFiles), implode(', ', $styledEntrypointNames)));
 
         if ($this->isDebug) {
             $io->warning(sprintf(
-                'You are compiling assets in development. Symfony will not serve any changed assets until you delete the "%s" directory.',
-                $this->shortenPath($outputDir)
+                'You are compiling assets in development. Symfony will not serve any changed assets until you delete the files in the "%s" directory.',
+                $this->shortenPath(\dirname($manifestPath))
             ));
         }
 
@@ -130,20 +102,18 @@ private function shortenPath(string $path): string
         return str_replace($this->projectDir.'/', '', $path);
     }
 
-    private function createManifestAndWriteFiles(SymfonyStyle $io, string $publicDir): array
+    private function createManifestAndWriteFiles(SymfonyStyle $io): array
     {
         $allAssets = $this->assetMapper->allAssets();
 
-        $io->comment(sprintf('Compiling assets to <info>%s%s</info>', $publicDir, $this->publicAssetsPathResolver->resolvePublicPath('')));
+        $io->comment(sprintf('Compiling and writing asset files to <info>%s</info>', $this->shortenPath($this->assetsFilesystem->getDestinationPath())));
         $manifest = [];
         foreach ($allAssets as $asset) {
-            // $asset->getPublicPath() will start with a "/"
-            $targetPath = $publicDir.$asset->publicPath;
             if (null !== $asset->content) {
                 // The original content has been modified by the AssetMapperCompiler
-                $this->filesystem->dumpFile($targetPath, $asset->content);
+                $this->assetsFilesystem->write($asset->publicPath, $asset->content);
             } else {
-                $this->filesystem->copy($asset->sourcePath, $targetPath, true);
+                $this->assetsFilesystem->copy($asset->sourcePath, $asset->publicPath);
             }
 
             $manifest[$asset->logicalPath] = $asset->publicPath;

CompiledAssetMapperConfigReader.php

@@ -0,0 +1,52 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\AssetMapper;
+
+use Symfony\Component\Filesystem\Path;
+
+/**
+ * Reads and writes compiled configuration files for asset mapper.
+ */
+class CompiledAssetMapperConfigReader
+{
+    public function __construct(private readonly string $directory)
+    {
+    }
+
+    public function configExists(string $filename): bool
+    {
+        return is_file(Path::join($this->directory, $filename));
+    }
+
+    public function loadConfig(string $filename): array
+    {
+        return json_decode(file_get_contents(Path::join($this->directory, $filename)), true, 512, \JSON_THROW_ON_ERROR);
+    }
+
+    public function saveConfig(string $filename, array $data): string
+    {
+        $path = Path::join($this->directory, $filename);
+        @mkdir(\dirname($path), 0777, true);
+        file_put_contents($path, json_encode($data, \JSON_PRETTY_PRINT | \JSON_THROW_ON_ERROR));
+
+        return $path;
+    }
+
+    public function removeConfig(string $filename): void
+    {
+        $path = Path::join($this->directory, $filename);
+
+        if (is_file($path)) {
+            unlink($path);
+        }
+    }
+}

Event/PreAssetsCompileEvent.php

@@ -21,20 +21,13 @@
  */
 class PreAssetsCompileEvent extends Event
 {
-    private string $outputDir;
     private OutputInterface $output;
 
-    public function __construct(string $outputDir, OutputInterface $output)
+    public function __construct(OutputInterface $output)
     {
-        $this->outputDir = $outputDir;
         $this->output = $output;
     }
 
-    public function getOutputDir(): string
-    {
-        return $this->outputDir;
-    }
-
     public function getOutput(): OutputInterface
     {
         return $this->output;

ImportMap/ImportMapGenerator.php

@@ -12,9 +12,9 @@
 namespace Symfony\Component\AssetMapper\ImportMap;
 
 use Symfony\Component\AssetMapper\AssetMapperInterface;
+use Symfony\Component\AssetMapper\CompiledAssetMapperConfigReader;
 use Symfony\Component\AssetMapper\Exception\LogicException;
 use Symfony\Component\AssetMapper\MappedAsset;
-use Symfony\Component\AssetMapper\Path\PublicAssetsPathResolverInterface;
 
 /**
  * Provides data needed to write the importmap & preloads.
@@ -26,7 +26,7 @@ class ImportMapGenerator
 
     public function __construct(
         private readonly AssetMapperInterface $assetMapper,
-        private readonly PublicAssetsPathResolverInterface $assetsPathResolver,
+        private readonly CompiledAssetMapperConfigReader $compiledConfigReader,
         private readonly ImportMapConfigReader $importMapConfigReader,
     ) {
     }
@@ -87,9 +87,8 @@ public function getImportMapData(array $entrypointNames): array
      */
     public function getRawImportMapData(): array
     {
-        $dumpedImportMapPath = $this->assetsPathResolver->getPublicFilesystemPath().'/'.self::IMPORT_MAP_CACHE_FILENAME;
-        if (is_file($dumpedImportMapPath)) {
-            return json_decode(file_get_contents($dumpedImportMapPath), true, 512, \JSON_THROW_ON_ERROR);
+        if ($this->compiledConfigReader->configExists(self::IMPORT_MAP_CACHE_FILENAME)) {
+            return $this->compiledConfigReader->loadConfig(self::IMPORT_MAP_CACHE_FILENAME);
         }
 
         $allEntries = [];
@@ -122,9 +121,8 @@ public function getRawImportMapData(): array
      */
     public function findEagerEntrypointImports(string $entryName): array
     {
-        $dumpedEntrypointPath = $this->assetsPathResolver->getPublicFilesystemPath().'/'.sprintf(self::ENTRYPOINT_CACHE_FILENAME_PATTERN, $entryName);
-        if (is_file($dumpedEntrypointPath)) {
-            return json_decode(file_get_contents($dumpedEntrypointPath), true, 512, \JSON_THROW_ON_ERROR);
+        if ($this->compiledConfigReader->configExists(sprintf(self::ENTRYPOINT_CACHE_FILENAME_PATTERN, $entryName))) {
+            return $this->compiledConfigReader->loadConfig(sprintf(self::ENTRYPOINT_CACHE_FILENAME_PATTERN, $entryName));
         }
 
         $rootImportEntries = $this->importMapConfigReader->getEntries();
@@ -202,13 +200,6 @@ private function addImplicitEntries(ImportMapEntry $entry, array $currentImportE
         return $currentImportEntries;
     }
 
-    private function findRootImportMapEntry(string $moduleName): ?ImportMapEntry
-    {
-        $entries = $this->importMapConfigReader->getEntries();
-
-        return $entries->has($moduleName) ? $entries->get($moduleName) : null;
-    }
-
     /**
      * Finds the MappedAsset allowing for a "logical path", relative or absolute filesystem path.
      */

Path/LocalPublicAssetsFilesystem.php

@@ -0,0 +1,43 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\AssetMapper\Path;
+
+use Symfony\Component\Filesystem\Filesystem;
+
+class LocalPublicAssetsFilesystem implements PublicAssetsFilesystemInterface
+{
+    private Filesystem $filesystem;
+
+    public function __construct(private readonly string $publicDir)
+    {
+        $this->filesystem = new Filesystem();
+    }
+
+    public function write(string $path, string $contents): void
+    {
+        $targetPath = $this->publicDir.'/'.ltrim($path, '/');
+
+        $this->filesystem->dumpFile($targetPath, $contents);
+    }
+
+    public function copy(string $originPath, string $path): void
+    {
+        $targetPath = $this->publicDir.'/'.ltrim($path, '/');
+
+        $this->filesystem->copy($originPath, $targetPath, true);
+    }
+
+    public function getDestinationPath(): string
+    {
+        return $this->publicDir;
+    }
+}

Path/PublicAssetsFilesystemInterface.php

@@ -0,0 +1,33 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\AssetMapper\Path;
+
+/**
+ * Writes asset files to their public location.
+ */
+interface PublicAssetsFilesystemInterface
+{
+    /**
+     * Write the contents of a file to the public location.
+     */
+    public function write(string $path, string $contents): void;
+
+    /**
+     * Copy a local file to the public location.
+     */
+    public function copy(string $originPath, string $path): void;
+
+    /**
+     * A string representation of the public directory, used for feedback.
+     */
+    public function getDestinationPath(): string;
+}