shipit-cli 0.13.4__py3-none-any.whl → 0.15.0__py3-none-any.whl

shipit/providers/node_static.py

@@ -1,11 +1,10 @@
-from __future__ import annotations
-
 import json
 import yaml
 from pathlib import Path
-from typing import Dict, Optional, Any, Set
+from typing import Dict, Optional, Any, Set, List
 from enum import Enum
 from semantic_version import Version, NpmSpec
+from pydantic import Field
 
 
 from .base import (
@@ -15,9 +14,10 @@ from .base import (
     MountSpec,
     ServiceSpec,
     VolumeSpec,
-    CustomCommands,
+    Config,
 )
-from .staticfile import StaticFileProvider
+from .staticfile import StaticFileProvider, StaticFileConfig
+from pydantic_settings import SettingsConfigDict
 
 
 class PackageManager(Enum):
@@ -46,7 +46,7 @@ class PackageManager(Enum):
 
         return DependencySpec(
             dep_name,
-            env_var=f"SHIPIT_{dep_name.upper()}_VERSION",
+            var_name=f"config.{dep_name.lower()}_version",
             default_version=default_version,
         )
 
@@ -78,8 +78,8 @@ class PackageManager(Enum):
     def install_command(self, has_lockfile: bool = False) -> str:
         return {
             PackageManager.NPM: f"npm {'ci' if has_lockfile else 'install'}",
-            PackageManager.PNPM: f"pnpm install{' --frozen-lockfile' if has_lockfile else ''}",
-            PackageManager.YARN: f"yarn install{' --frozen-lockfile' if has_lockfile else ''}",
+            PackageManager.PNPM: "pnpm install",
+            PackageManager.YARN: "yarn install",
             PackageManager.BUN: f"bun install{' --no-save' if has_lockfile else ''}",
         }[self]
 
@@ -105,6 +105,7 @@ class StaticGenerator(Enum):
     VITE = "vite"
     NEXT = "next"
     GATSBY = "gatsby"
+    DOCUSAURUS_OLD = "docusaurus-old"
     DOCUSAURUS = "docusaurus"
     SVELTE = "svelte"
     REMIX = "remix"
@@ -113,55 +114,146 @@ class StaticGenerator(Enum):
     REMIX_OLD = "remix-old"
     REMIX_V2 = "remix-v2"
 
+    def get_output_dir(self) -> str:
+        if self == StaticGenerator.NEXT:
+            return "out"
+        elif self == StaticGenerator.NUXT_V3:
+            return ".output/public"
+        elif self in [
+            StaticGenerator.ASTRO,
+            StaticGenerator.VITE,
+            StaticGenerator.NUXT_OLD,
+            StaticGenerator.REMIX_V2,
+        ]:
+            return "dist"
+        elif self == StaticGenerator.GATSBY:
+            return "public"
+        elif self == StaticGenerator.REMIX_OLD:
+            return "build/client"
+        elif self in [
+            StaticGenerator.DOCUSAURUS,
+            StaticGenerator.DOCUSAURUS_OLD,
+            StaticGenerator.SVELTE,
+        ]:
+            return "build"
+        else:
+            return "dist"
 
-class NodeStaticProvider(StaticFileProvider):
-    package_manager: PackageManager
-    package_json: Optional[Dict[str, Any]]
-    extra_dependencies: Set[str]
+    @classmethod
+    def detect_generators_from_command(cls, build_command) -> List["StaticGenerator"]:
+        commands = {
+            "gatsby": [StaticGenerator.GATSBY],
+            "astro": [StaticGenerator.ASTRO],
+            "remix-ssg": [StaticGenerator.REMIX_OLD],
+            "vite": [StaticGenerator.VITE, StaticGenerator.REMIX_V2],
+            "docusaurus": [StaticGenerator.DOCUSAURUS, StaticGenerator.DOCUSAURUS_OLD],
+            "next": [StaticGenerator.NEXT],
+            "nuxi": [StaticGenerator.NUXT_V3],
+            "nuxt": [StaticGenerator.NUXT_OLD],
+            "svelte-kit": [StaticGenerator.SVELTE],
+        }
+        build_command = build_command.split(" ")[0]
+        if build_command in commands:
+            return commands[build_command]
+        else:
+            return []
+    
+    def build_command(self) -> str:
+        return {
+            StaticGenerator.GATSBY: "gatsby build",
+            StaticGenerator.ASTRO: "astro build",
+            StaticGenerator.REMIX_OLD: "remix-ssg build",
+            StaticGenerator.REMIX_V2: "vite build",
+            StaticGenerator.DOCUSAURUS: "docusaurus build",
+            StaticGenerator.DOCUSAURUS_OLD: "docusaurus build",
+            StaticGenerator.SVELTE: "svelte-kit build",
+            StaticGenerator.VITE: "vite build",
+            StaticGenerator.NEXT: "next export",
+            StaticGenerator.NUXT_V3: "nuxi generate",
+            StaticGenerator.NUXT_OLD: "nuxt generate",
+            StaticGenerator.REMIX: "remix-ssg build",
+        }[self]
+
+
+class NodeStaticConfig(StaticFileConfig):
+    model_config = SettingsConfigDict(extra="ignore", env_prefix="SHIPIT_")
+
+    package_manager: Optional[PackageManager] = None
+    extra_dependencies: Set[str] = Field(default_factory=set)
     static_generator: Optional[StaticGenerator] = None
+    build_command: Optional[str] = None
+    node_version: Optional[str] = "22"
+    npm_version: Optional[str] = None
+    pnpm_version: Optional[str] = None
+    yarn_version: Optional[str] = None
+    bun_version: Optional[str] = None
 
-    def __init__(self, path: Path, custom_commands: CustomCommands):
-        super().__init__(path, custom_commands)
-        if (path / "package-lock.json").exists():
-            self.package_manager = PackageManager.NPM
-        elif (path / "pnpm-lock.yaml").exists():
-            self.package_manager = PackageManager.PNPM
-        elif (path / "yarn.lock").exists():
-            self.package_manager = PackageManager.YARN
-        elif (path / "bun.lockb").exists():
-            self.package_manager = PackageManager.BUN
-        else:
-            self.package_manager = PackageManager.PNPM
-
-        self.package_json = self.parse_package_json(path)
-
-        if self.has_dependency(self.package_json, "gatsby"):
-            self.static_generator = StaticGenerator.GATSBY
-        elif self.has_dependency(self.package_json, "astro"):
-            self.static_generator = StaticGenerator.ASTRO
-        elif self.has_dependency(self.package_json, "@docusaurus/core"):
-            self.static_generator = StaticGenerator.DOCUSAURUS
-        elif self.has_dependency(self.package_json, "svelte"):
-            self.static_generator = StaticGenerator.SVELTE
-        elif self.has_dependency(
-            self.package_json, "@remix-run/dev", "1"
-        ) or self.has_dependency(self.package_json, "@remix-run/dev", "0"):
-            self.static_generator = StaticGenerator.REMIX_OLD
-        elif self.has_dependency(self.package_json, "@remix-run/dev"):
-            self.static_generator = StaticGenerator.REMIX_V2
-        elif self.has_dependency(self.package_json, "vite"):
-            self.static_generator = StaticGenerator.VITE
-        elif self.has_dependency(self.package_json, "next"):
-            self.static_generator = StaticGenerator.NEXT
-        elif self.has_dependency(self.package_json, "nuxt", "2") or self.has_dependency(
-            self.package_json, "nuxt", "1"
-        ):
-            self.static_generator = StaticGenerator.NUXT_OLD
-        elif self.has_dependency(self.package_json, "nuxt"):
-            self.static_generator = StaticGenerator.NUXT_V3
-
-        # if self.has_dependency(self.package_json, "sharp"):
-        #     self.extra_dependencies.add("libvips")
+
+class NodeStaticProvider(StaticFileProvider):
+    only_build: bool = False
+
+    def __init__(
+        self, path: Path, config: NodeStaticConfig, only_build: bool = False
+    ):
+        super().__init__(path, config)
+        self.only_build = only_build
+
+    @classmethod
+    def load_config(
+        cls, path: Path, base_config: Config
+    ) -> NodeStaticConfig:
+        config = NodeStaticConfig(**base_config.model_dump())
+        if not config.package_manager:
+            if (path / "package-lock.json").exists():
+                config.package_manager = PackageManager.NPM
+            elif (path / "pnpm-lock.yaml").exists():
+                config.package_manager = PackageManager.PNPM
+            elif (path / "yarn.lock").exists():
+                config.package_manager = PackageManager.YARN
+            elif (path / "bun.lockb").exists():
+                config.package_manager = PackageManager.BUN
+            else:
+                config.package_manager = PackageManager.PNPM
+
+        package_json = cls.parse_package_json(path)
+
+        if not config.static_generator:
+            if cls.has_dependency(package_json, "gatsby"):
+                config.static_generator = StaticGenerator.GATSBY
+            elif cls.has_dependency(package_json, "astro"):
+                config.static_generator = StaticGenerator.ASTRO
+            elif cls.has_dependency(package_json, "docusaurus"):
+                config.static_generator = StaticGenerator.DOCUSAURUS_OLD
+            elif cls.has_dependency(package_json, "@docusaurus/core"):
+                config.static_generator = StaticGenerator.DOCUSAURUS
+            elif cls.has_dependency(package_json, "svelte"):
+                config.static_generator = StaticGenerator.SVELTE
+            elif cls.has_dependency(
+                package_json, "@remix-run/dev", "1"
+            ) or cls.has_dependency(package_json, "@remix-run/dev", "0"):
+                config.static_generator = StaticGenerator.REMIX_OLD
+            elif cls.has_dependency(package_json, "@remix-run/dev"):
+                config.static_generator = StaticGenerator.REMIX_V2
+            elif cls.has_dependency(package_json, "vite"):
+                config.static_generator = StaticGenerator.VITE
+            elif cls.has_dependency(package_json, "next"):
+                config.static_generator = StaticGenerator.NEXT
+            elif cls.has_dependency(package_json, "nuxt", "2") or cls.has_dependency(
+                package_json, "nuxt", "1"
+            ):
+                config.static_generator = StaticGenerator.NUXT_OLD
+            elif cls.has_dependency(package_json, "nuxt"):
+                config.static_generator = StaticGenerator.NUXT_V3
+
+        if not config.build_command:
+            config.build_command = cls.get_build_command(
+                package_json, config.package_manager, config.static_generator
+            )
+
+        if not config.static_dir:
+            config.static_dir = config.static_generator.get_output_dir()
+
+        return config
 
     @classmethod
     def parse_package_json(cls, path: Path) -> Optional[Dict[str, Any]]:
@@ -205,8 +297,27 @@ class NodeStaticProvider(StaticFileProvider):
 
     @classmethod
     def detect(
-        cls, path: Path, custom_commands: CustomCommands
+        cls, path: Path, config: Config
     ) -> Optional[DetectResult]:
+        if config.commands.install:
+            # Detect this provider from the install command
+            if config.commands.install in ["npm install", "npm ci", "npm i", "pnpm install", "pnpm ci", "pnpm i", "yarn install", "yarn ci", "yarn i", "bun install", "bun ci", "bun i"]:
+                return DetectResult(cls.name(), 40)
+
+        if config.commands.build:
+            if config.commands.build.startswith("npm run "):
+                return DetectResult(cls.name(), 40)
+            elif config.commands.build.startswith("pnpm run "):
+                return DetectResult(cls.name(), 40)
+            elif config.commands.build.startswith("yarn run "):
+                return DetectResult(cls.name(), 40)
+            elif config.commands.build.startswith("bun run "):
+                return DetectResult(cls.name(), 40)
+
+            static_generators = StaticGenerator.detect_generators_from_command(config.commands.build)
+            if static_generators:
+                return DetectResult(cls.name(), 40)
+
         package_json = cls.parse_package_json(path)
         if not package_json:
             return None
@@ -217,6 +328,7 @@ class NodeStaticProvider(StaticFileProvider):
             "nuxt",
             "gatsby",
             "svelte",
+            "docusaurus",
             "@docusaurus/core",
             "@remix-run/dev",
         ]
@@ -224,109 +336,80 @@ class NodeStaticProvider(StaticFileProvider):
             return DetectResult(cls.name(), 40)
         return None
 
-    def initialize(self) -> None:
-        pass
-
-    def serve_name(self) -> str:
-        return self.path.name
-
-    def platform(self) -> Optional[str]:
-        return self.static_generator.value if self.static_generator else None
+    def serve_name(self) -> Optional[str]:
+        return None
 
     def dependencies(self) -> list[DependencySpec]:
-        package_manager_dep = self.package_manager.as_dependency(self.path)
+        package_manager_dep = self.config.package_manager.as_dependency(self.path)
         package_manager_dep.use_in_build = True
         return [
             DependencySpec(
                 "node",
-                env_var="SHIPIT_NODE_VERSION",
-                default_version="22",
+                var_name="config.node_version",
                 use_in_build=True,
             ),
             package_manager_dep,
-            DependencySpec("static-web-server", use_in_serve=True),
+            *super().dependencies(),
         ]
 
-    def declarations(self) -> Optional[str]:
-        return None
-
-    def get_output_dir(self) -> str:
-        if self.static_generator == StaticGenerator.NEXT:
-            return "out"
-        elif self.static_generator in [
-            StaticGenerator.ASTRO,
-            StaticGenerator.VITE,
-            StaticGenerator.NUXT_OLD,
-            StaticGenerator.NUXT_V3,
-            StaticGenerator.REMIX_V2,
-        ]:
-            return "dist"
-        elif self.static_generator == StaticGenerator.GATSBY:
-            return "public"
-        elif self.static_generator == StaticGenerator.REMIX_OLD:
-            return "build/client"
-        elif self.static_generator in [
-            StaticGenerator.DOCUSAURUS,
-            StaticGenerator.SVELTE,
-        ]:
-            return "build"
-        else:
-            return "dist"
-
-    def get_build_command(self) -> bool:
-        if not self.package_json:
-            return False
-        build_command = self.package_json.get("scripts", {}).get("build")
-        if build_command:
-            return self.package_manager.run_command("build")
-        if self.static_generator == StaticGenerator.GATSBY:
-            return self.package_manager.run_execute_command("gatsby build")
-        if self.static_generator == StaticGenerator.ASTRO:
-            return self.package_manager.run_execute_command("astro build")
-        elif self.static_generator == StaticGenerator.REMIX_OLD:
-            return self.package_manager.run_execute_command("remix-ssg build")
-        elif self.static_generator == StaticGenerator.REMIX_V2:
-            return self.package_manager.run_execute_command("vite build")
-        elif self.static_generator == StaticGenerator.DOCUSAURUS:
-            return self.package_manager.run_execute_command("docusaurus build")
-        elif self.static_generator == StaticGenerator.SVELTE:
-            return self.package_manager.run_execute_command("svelte-kit build")
-        elif self.static_generator == StaticGenerator.VITE:
-            return self.package_manager.run_execute_command("vite build")
-        elif self.static_generator == StaticGenerator.NEXT:
-            return self.package_manager.run_execute_command("next export")
-        elif self.static_generator == StaticGenerator.NUXT_V3:
-            return self.package_manager.run_execute_command("nuxi generate")
-        elif self.static_generator == StaticGenerator.NUXT_OLD:
-            return self.package_manager.run_execute_command("nuxt generate")
-        return False
+    @classmethod
+    def get_build_command(
+        cls,
+        package_json: Optional[Dict[str, Any]],
+        package_manager: PackageManager,
+        static_generator: StaticGenerator,
+    ) -> Optional[str]:
+        if package_json:
+            scripts = package_json.get("scripts", {})
+            generate_command = scripts.get("generate")
+            if generate_command:
+                return package_manager.run_command("generate")
+            build_command = scripts.get("build")
+            if build_command:
+                return package_manager.run_command("build")
+        command = static_generator.build_command()
+        return package_manager.run_execute_command(command)
 
     def build_steps(self) -> list[str]:
-        output_dir = self.get_output_dir()
-        get_build_command = self.get_build_command()
-        lockfile = self.package_manager.lockfile()
+        lockfile = self.config.package_manager.lockfile()
         has_lockfile = (self.path / lockfile).exists()
-        install_command = self.package_manager.install_command(
+        install_command = self.config.package_manager.install_command(
             has_lockfile=has_lockfile
         )
-        input_files = ["package.json"]
+        ignored_files = ["node_modules", ".git"]
         if has_lockfile:
-            input_files.append(lockfile)
-        inputs_install_files = ", ".join([f'"{file}"' for file in input_files])
-
-        return [
-            'workdir(temp["build"])',
-            # 'run("npx corepack enable", inputs=["package.json"], group="install")',
-            f'run("{install_command}", inputs=[{inputs_install_files}], group="install")',
-            'copy(".", ".", ignore=["node_modules", ".git"])',
-            f'run("{get_build_command}", outputs=["{output_dir}"], group="build")',
-            f'run("cp -R {output_dir}/* {{}}/".format(app["build"]))',
-        ]
+            ignored_files.append(lockfile)
+        all_ignored_files = ", ".join([f'"{file}"' for file in ignored_files])
+
+        return filter(
+            None,
+            [
+                'workdir(temp.path)' if not self.only_build else None,
+                f'copy("{lockfile}")' if has_lockfile else None,
+                'env(CI="true", NODE_ENV="production", NPM_CONFIG_FUND="false")'
+                if self.config.package_manager == PackageManager.NPM
+                else None,
+                # 'run("npx corepack enable", inputs=["package.json"], group="install")',
+                f'run("{install_command}", inputs=["package.json"], group="install")',
+                f'copy(".", ignore=[{all_ignored_files}])',
+                f'run("{self.config.build_command}", outputs=[config.static_dir], group="build")'
+                if not self.only_build
+                else None,
+                f'run("{self.config.build_command}", group="build")'
+                if self.only_build
+                else None,
+                'run("cp -R {}/* {}/".format(config.static_dir, static_app.path))'
+                if not self.only_build
+                else None,
+            ],
+        )
 
     def prepare_steps(self) -> Optional[list[str]]:
         return None
 
     def mounts(self) -> list[MountSpec]:
+        if self.only_build:
+            return []
         return [MountSpec("temp", attach_to_serve=False), *super().mounts()]
 
     def volumes(self) -> list[VolumeSpec]:

shipit/providers/php.py

@@ -1,8 +1,6 @@
-from __future__ import annotations
-
 import json
 from pathlib import Path
-from typing import Dict, Optional
+from typing import Dict, Optional, Literal
 
 from .base import (
     DetectResult,
@@ -12,17 +10,35 @@ from .base import (
     MountSpec,
     ServiceSpec,
     VolumeSpec,
-    CustomCommands,
+    Config,
 )
+from pydantic_settings import SettingsConfigDict
+
+
+class PhpConfig(Config):
+    model_config = SettingsConfigDict(extra="ignore", env_prefix="SHIPIT_")
+
+    use_composer: bool = False
+    php_version: Optional[str] = "8.3"
+    php_architecture: Optional[Literal["64-bit", "32-bit"]] = "64-bit"
 
 
 class PhpProvider:
-    def __init__(self, path: Path, custom_commands: CustomCommands):
+    def __init__(self, path: Path, config: PhpConfig):
         self.path = path
-        self.custom_commands = custom_commands
-        self.has_composer = _exists(self.path, "composer.json", "composer.lock") or (
-            custom_commands.install and custom_commands.install.startswith("composer ")
+        self.config = config
+
+    @classmethod
+    def load_config(cls, path: Path, base_config: Config) -> PhpConfig:
+        use_composer = (
+            _exists(path, "composer.json", "composer.lock")
+            or (
+                base_config.commands.install
+                and base_config.commands.install.startswith("composer ")
+            )
+            or False
         )
+        return PhpConfig(use_composer=use_composer, **base_config.model_dump())
 
     @classmethod
     def name(cls) -> str:
@@ -30,7 +46,7 @@ class PhpProvider:
 
     @classmethod
     def detect(
-        cls, path: Path, custom_commands: CustomCommands
+        cls, path: Path, config: Config
     ) -> Optional[DetectResult]:
         if _exists(path, "composer.json") and _exists(path, "public/index.php"):
             return DetectResult(cls.name(), 60)
@@ -40,55 +56,46 @@ class PhpProvider:
             or _exists(path, "app/index.php")
         ):
             return DetectResult(cls.name(), 10)
-        if custom_commands.start and custom_commands.start.startswith("php "):
+        if config.commands.start and config.commands.start.startswith("php "):
             return DetectResult(cls.name(), 70)
-        if custom_commands.install and custom_commands.install.startswith("composer "):
+        if config.commands.install and config.commands.install.startswith("composer "):
             return DetectResult(cls.name(), 30)
         return None
 
-    def initialize(self) -> None:
-        pass
-
-    def serve_name(self) -> str:
-        return self.path.name
-
-    def platform(self) -> Optional[str]:
+    def serve_name(self) -> Optional[str]:
         return None
 
     def dependencies(self) -> list[DependencySpec]:
         deps = [
             DependencySpec(
                 "php",
-                env_var="SHIPIT_PHP_VERSION",
-                default_version="8.3",
-                architecture_var="SHIPIT_PHP_ARCHITECTURE",
+                var_name="config.php_version",
+                architecture_var_name="config.php_architecture",
                 use_in_build=True,
                 use_in_serve=True,
             ),
         ]
-        if self.has_composer:
+        if self.config.use_composer:
             deps.append(DependencySpec("composer", use_in_build=True))
             deps.append(DependencySpec("bash", use_in_serve=True))
         return deps
 
     def declarations(self) -> Optional[str]:
-        if self.has_composer:
-            return 'HOME = getenv("HOME")\n'
         return None
 
     def build_steps(self) -> list[str]:
         steps = [
-            'workdir(app["build"])',
+            'workdir(app.path)',
         ]
         if _exists(self.path, "php.ini"):
-            steps.append('copy("php.ini", "{}/php.ini".format(assets["build"]))')
+            steps.append('copy("php.ini", "{}/php.ini".format(assets.path))')
         else:
             steps.append(
-                'copy("php/php.ini", "{}/php.ini".format(assets["build"]), base="assets")'
+                'copy("php/php.ini", "{}/php.ini".format(assets.path), base="assets")'
             )
 
-        if self.has_composer:
-            steps.append('env(HOME=HOME, COMPOSER_FUND="0")')
+        if self.config.use_composer:
+            steps.append('env(COMPOSER_HOME="/tmp", COMPOSER_FUND="0")')
             steps.append(
                 'run("composer install --optimize-autoloader --no-scripts --no-interaction", inputs=["composer.json", "composer.lock"], outputs=["."], group="install")'
             )
@@ -100,24 +107,21 @@ class PhpProvider:
         return None
 
     def commands(self) -> Dict[str, str]:
-        commands = self.base_commands()
-        if self.custom_commands.start:
-            commands["start"] = json.dumps(self.custom_commands.start)
-        return commands
+        return self.base_commands()
 
     def base_commands(self) -> Dict[str, str]:
         if _exists(self.path, "public/index.php"):
             return {
-                "start": '"php -S localhost:{} -t {}/public".format(PORT, app["serve"])'
+                "start": '"php -S localhost:{} -t {}/public".format(PORT, app.serve_path)'
             }
         elif _exists(self.path, "app/index.php"):
             return {
-                "start": '"php -S localhost:{} -t {}/app".format(PORT, app["serve"])'
+                "start": '"php -S localhost:{} -t {}/app".format(PORT, app.serve_path)'
             }
         elif _exists(self.path, "index.php"):
-            return {"start": '"php -S localhost:{} -t {}".format(PORT, app["serve"])'}
+            return {"start": '"php -S localhost:{} -t {}".format(PORT, app.serve_path)'}
         return {
-            "start": '"php -S localhost:{} -t {}".format(PORT, app["serve"])',
+            "start": '"php -S localhost:{} -t {}".format(PORT, app.serve_path)',
         }
 
     def mounts(self) -> list[MountSpec]:
@@ -131,7 +135,7 @@ class PhpProvider:
 
     def env(self) -> Optional[Dict[str, str]]:
         return {
-            "PHP_INI_SCAN_DIR": '"{}".format(assets["serve"])',
+            "PHP_INI_SCAN_DIR": '"{}".format(assets.serve_path)',
         }
 
     def services(self) -> list[ServiceSpec]: