simple-module-cli 0.0.13__tar.gz → 0.0.15__tar.gz

{simple_module_cli-0.0.13 → simple_module_cli-0.0.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simple_module_cli
-Version: 0.0.13
+Version: 0.0.15
 Summary: Standalone scaffolder for the SimpleModule framework — `smpy new`, `smpy create-module`, plugin host.
 Project-URL: Homepage, https://github.com/antosubash/simple_module_python
 Project-URL: Repository, https://github.com/antosubash/simple_module_python

{simple_module_cli-0.0.13 → simple_module_cli-0.0.15}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "simple_module_cli"
-version = "0.0.13"
+version = "0.0.15"
 description = "Standalone scaffolder for the SimpleModule framework — `smpy new`, `smpy create-module`, plugin host."
 readme = "README.md"
 license = "MIT"

{simple_module_cli-0.0.13 → simple_module_cli-0.0.15}/simple_module_cli/case.py

@@ -41,6 +41,11 @@ def to_snake_case(name: str) -> str:
     s = re.sub(r"[\s\-]+", "_", name)
     s = re.sub(r"(.)([A-Z][a-z]+)", r"\1_\2", s)
     s = re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", s)
+    # Collapse runs of underscores that the boundary regexes can introduce
+    # when the input already contained a separator (e.g. ``My Feature`` →
+    # ``My_Feature`` → ``My__Feature``). Without this the PyPI slug emits a
+    # double hyphen.
+    s = re.sub(r"_+", "_", s)
     return s.lower()
 
 

{simple_module_cli-0.0.13 → simple_module_cli-0.0.15}/simple_module_cli/scaffolding.py

@@ -193,20 +193,30 @@ def create_module(
     template_root: Path | None = None,
 ) -> Path:
     dest = Path(dest)
+    existed_before = dest.exists()
     _require_empty_dest(dest)
     display_name = to_pascal_case(name)
     slug = to_kebab_case(name)
     package_name = to_snake_case(name)
-    _apply_template_files(
-        _resolve_template_root("module", template_root),
-        dest,
-        substitutions={
-            "{{MODULE_NAME}}": display_name,
-            "{{MODULE_SLUG}}": slug,
-            "{{PACKAGE_NAME}}": package_name,
-            "{{PACKAGE_NAME_UPPER}}": package_name.upper(),
-        },
-        path_rewrites={_PACKAGE_PATH_TOKEN: package_name},
-    )
+    try:
+        _apply_template_files(
+            _resolve_template_root("module", template_root),
+            dest,
+            substitutions={
+                "{{MODULE_NAME}}": display_name,
+                "{{MODULE_SLUG}}": slug,
+                "{{PACKAGE_NAME}}": package_name,
+                "{{PACKAGE_NAME_UPPER}}": package_name.upper(),
+            },
+            path_rewrites={_PACKAGE_PATH_TOKEN: package_name},
+        )
+    except Exception:
+        # Rollback so a half-scaffolded directory doesn't leave the user
+        # with an unparseable Python package and the impression that a
+        # retry won't work because ``dest`` is now non-empty. We only
+        # nuke the directory we created — never one we found pre-existing.
+        if not existed_before and dest.is_dir():
+            shutil.rmtree(dest, ignore_errors=True)
+        raise
     logger.info("Scaffolded module '%s' at %s (package: %s)", display_name, dest, package_name)
     return dest

{simple_module_cli-0.0.13 → simple_module_cli-0.0.15}/simple_module_cli/templates/host/client_app/vite.config.ts

@@ -68,7 +68,6 @@ if (fs.existsSync(manifestPath)) {
     }
   }
 }
-const fsRootPrefix = fsRoot + path.sep;
 const fakeWorkspaceImporter = path.join(fsRoot, 'package.json');
 
 // CJS-only deps like `clsx`, `tailwind-merge`, `class-variance-authority`
@@ -158,11 +157,13 @@ function collectOptimizeIncludes(): string[] {
 
 // Cross-package bare imports from module pages (`maplibre-gl`, `pmtiles`,
 // `@inertiajs/react`, …) live in fsRoot/node_modules after `npm install`.
-// But when a module's pages sit outside fsRoot — under
-// `.venv/.../site-packages/<pkg>/pages/` for wheel installs — Vite's
-// resolver walks up from the importer looking for node_modules and never
-// reaches fsRoot/node_modules. Resolution fails with: "Failed to resolve
-// import … Does the file exist?".
+// But Vite's resolver walks up from the importer looking for node_modules
+// and doesn't always reach fsRoot/node_modules — true for wheel installs
+// under `.venv/.../site-packages/<pkg>/pages/` (outside fsRoot) AND for
+// workspace-member modules at `modules/<name>/<pkg>/pages/` whose upward
+// walk hits intermediate dirs without node_modules before reaching the
+// hoisted workspace root. Resolution fails with: "Failed to resolve import
+// … Does the file exist?".
 //
 // This plugin recovers by retrying any unresolved bare import from a
 // module-pages importer as if the importer lived at fsRoot, which puts
@@ -184,7 +185,6 @@ function moduleBareImportResolver(): Plugin {
         return null;
       }
       const importerPath = importer.split('?')[0];
-      if (importerPath.startsWith(fsRootPrefix)) return null;
       if (!modulePagesPrefixes.some((prefix) => importerPath.startsWith(prefix))) {
         return null;
       }
@@ -205,6 +205,16 @@ export default defineConfig({
   optimizeDeps: {
     entries: ['main.tsx', 'pages/**/*.tsx', ...moduleOptimizeEntries],
     include: collectOptimizeIncludes(),
+    // Vite's dep scanner runs esbuild against every entry above. When the
+    // entry sits outside the workspace (a wheel-installed module's
+    // pages/, or sometimes even a workspace module's pages/), esbuild's
+    // upward node_modules walk from the importer does not always reach
+    // the hoisted node_modules at fsRoot. Seeding it as NODE_PATH-style
+    // fallback ensures bare specifiers like `maplibre-gl` resolve during
+    // scan-imports. See GitHub issue #152.
+    esbuildOptions: {
+      nodePaths: [path.join(fsRoot, 'node_modules')],
+    },
   },
   build: {
     outDir: '../static/dist',

simple_module_cli-0.0.15/simple_module_cli/templates/host/main.py

@@ -0,0 +1,46 @@
+"""Host application entry point.
+
+This file was generated by `smpy create-host`. Modules are discovered at boot
+via entry_points; add them to this host's pyproject.toml to install them.
+"""
+
+import os
+from pathlib import Path
+
+from simple_module_core.dotenv import load_dotenv_into_environ
+
+# Resolve the workspace root from this file's location so the web process
+# behaves the same regardless of where uvicorn was launched (the scaffolded
+# Makefile uses ``cd host && uvicorn main:app``, but ``uv run --project host``
+# or a wheel deployment may run from elsewhere). chdir up front so cwd-relative
+# paths in ``.env`` (e.g. ``sqlite+aiosqlite:///./host/app.db``) resolve
+# consistently; load ``.env`` into ``os.environ`` so framework code reading
+# ``os.environ.get("SM_…")`` directly sees the same values pydantic does.
+_REPO_ROOT = Path(__file__).resolve().parent.parent
+os.chdir(_REPO_ROOT)
+load_dotenv_into_environ(_REPO_ROOT / ".env")
+
+from simple_module_hosting import Settings, create_app
+from simple_module_hosting.logging import setup_logging
+
+from routes import router as host_router
+
+settings = Settings()
+
+setup_logging(
+    level=settings.log_level,
+    json_format=settings.log_format == "json",
+)
+
+app = create_app(settings)
+app.include_router(host_router)
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(
+        "main:app",
+        host="0.0.0.0",
+        port=8000,
+        reload=settings.is_development,
+    )

simple_module_cli-0.0.15/tests/test_case.py

@@ -0,0 +1,63 @@
+"""Direct unit tests for the identifier case helpers.
+
+Every scaffolder pipes a user-supplied module name through these — a typo
+that emits ``u_r_l_path`` from ``URLPath`` would propagate into the PyPI
+slug *and* the display name. Existing tests touch ``to_pascal_case`` only
+indirectly via ``test_helpers.py``; we pin the snake/kebab forms too,
+including the acronym edge cases the docstring promises.
+"""
+
+from __future__ import annotations
+
+import pytest
+from simple_module_cli.case import to_kebab_case, to_pascal_case, to_snake_case
+
+
+class TestToSnakeCase:
+    @pytest.mark.parametrize(
+        ("raw", "expected"),
+        [
+            ("MyFeature", "my_feature"),
+            ("my-feature", "my_feature"),
+            ("my_feature", "my_feature"),
+            ("My Feature", "my_feature"),
+            ("MY_FEATURE", "my_feature"),
+            ("URLPath", "url_path"),
+            ("APIClient", "api_client"),
+            ("HTTPServer2", "http_server2"),
+            ("simple", "simple"),
+            ("simple-thing-name", "simple_thing_name"),
+            ("Already_Snake_Mixed", "already_snake_mixed"),
+            ("trailing-", "trailing_"),
+        ],
+    )
+    def test_canonicalises(self, raw, expected):
+        assert to_snake_case(raw) == expected
+
+
+class TestToKebabCase:
+    @pytest.mark.parametrize(
+        ("raw", "expected"),
+        [
+            ("MyFeature", "my-feature"),
+            ("my_feature", "my-feature"),
+            ("URLPath", "url-path"),
+        ],
+    )
+    def test_canonicalises(self, raw, expected):
+        assert to_kebab_case(raw) == expected
+
+
+class TestToPascalCase:
+    @pytest.mark.parametrize(
+        ("raw", "expected"),
+        [
+            ("my-feature", "MyFeature"),
+            ("my_feature", "MyFeature"),
+            ("MyFeature", "MyFeature"),
+            ("URLPath", "UrlPath"),  # consequence of the snake-cased pipeline
+            ("__name__", "Name"),  # empty parts dropped
+        ],
+    )
+    def test_canonicalises(self, raw, expected):
+        assert to_pascal_case(raw) == expected

simple_module_cli-0.0.15/tests/test_env_helper.py

@@ -0,0 +1,54 @@
+"""``set_env_key`` is the single helper that edits scaffold-time .env files.
+
+A regression here writes a duplicate ``KEY=`` line or, worse, leaves the old
+value unstripped — both manifest as "my recipe didn't take effect" which is
+hard to debug downstream.
+"""
+
+from __future__ import annotations
+
+from simple_module_cli._env import set_env_key
+
+
+def test_appends_to_empty_body():
+    assert set_env_key("", "FOO", "bar") == "FOO=bar\n"
+
+
+def test_replaces_existing_key():
+    body = "FOO=old\nBAR=keep\n"
+    out = set_env_key(body, "FOO", "new")
+    # Replaced line lives at the bottom (append-after-strip strategy).
+    assert "FOO=old" not in out
+    assert "FOO=new\n" in out
+    assert "BAR=keep" in out
+
+
+def test_unrelated_lines_preserved_in_order():
+    body = "A=1\nB=2\nC=3\n"
+    out = set_env_key(body, "Z", "9")
+    lines = out.splitlines()
+    assert lines[0] == "A=1"
+    assert lines[1] == "B=2"
+    assert lines[2] == "C=3"
+    assert lines[-1] == "Z=9"
+
+
+def test_idempotent_when_key_already_at_value():
+    body = "FOO=bar\n"
+    once = set_env_key(body, "FOO", "bar")
+    twice = set_env_key(once, "FOO", "bar")
+    assert once == twice == "FOO=bar\n"
+
+
+def test_prefix_match_is_exact():
+    """``KEY=`` must not match ``KEY_LONGER=``."""
+    body = "FOO_BAR=keep_me\n"
+    out = set_env_key(body, "FOO", "new")
+    assert "FOO_BAR=keep_me" in out
+    assert "FOO=new" in out
+
+
+def test_output_always_ends_with_newline():
+    body = "X=1"  # no trailing newline
+    out = set_env_key(body, "Y", "2")
+    assert out.endswith("\n")

simple_module_cli-0.0.15/tests/test_scaffold_rollback.py

@@ -0,0 +1,73 @@
+"""Scaffold rollback on partial failure.
+
+Before the rollback added to ``create_module``, a mid-pipeline error left
+the user with a non-empty destination directory — the next ``smpy new``
+invocation against the same path would then refuse to overwrite, but the
+files already written wouldn't form a valid Python package either.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+from simple_module_cli import scaffolding
+
+
+def test_create_module_rolls_back_on_template_failure(tmp_path, monkeypatch):
+    """An exception during ``_apply_template_files`` must clear ``dest``."""
+    dest = tmp_path / "broken_module"
+
+    def boom(*_args, **_kwargs):
+        # Simulate a mid-write error after the dest directory exists but
+        # before all files have been laid down.
+        dest.mkdir(exist_ok=True)
+        (dest / "half_written.py").write_text("# truncated", encoding="utf-8")
+        raise RuntimeError("simulated template engine failure")
+
+    monkeypatch.setattr(scaffolding, "_apply_template_files", boom)
+
+    with pytest.raises(RuntimeError, match="simulated template engine failure"):
+        scaffolding.create_module(dest, "my_thing")
+
+    assert not dest.exists(), (
+        "Partial scaffold left on disk — rollback didn't fire. Subsequent "
+        "smpy new attempts at this path would refuse to overwrite."
+    )
+
+
+def test_rollback_does_not_delete_pre_existing_directory(tmp_path, monkeypatch):
+    """A pre-existing (empty) destination must stay on disk on rollback.
+
+    We can't tell from inside ``create_module`` whether ``dest`` was made
+    by us or by the caller, but the directory's *prior existence* is a
+    reliable signal: if the caller mkdir'd it, leaving their dir alone is
+    the conservative choice. (The half-written scaffold contents inside
+    are an unavoidable consequence — preventing those needs a transactional
+    file system, which we don't have.)
+    """
+    dest = tmp_path / "owned_by_caller"
+    dest.mkdir()
+
+    def boom(*_args, **_kwargs):
+        raise RuntimeError("simulated failure before any files written")
+
+    monkeypatch.setattr(scaffolding, "_apply_template_files", boom)
+
+    with pytest.raises(RuntimeError):
+        scaffolding.create_module(dest, "thing")
+
+    # The dir survives — we didn't make it.
+    assert dest.exists()
+
+
+def test_successful_scaffold_keeps_dest():
+    """Sanity check: the rollback path only fires on failure."""
+    import tempfile
+
+    with tempfile.TemporaryDirectory() as tmp:
+        dest = Path(tmp) / "real_module"
+        scaffolding.create_module(dest, "real_module")
+        assert dest.exists()
+        # The template materialises at least the package directory.
+        assert any(dest.iterdir())

{simple_module_cli-0.0.13 → simple_module_cli-0.0.15}/tests/test_scaffolding_host.py

@@ -155,6 +155,28 @@ class TestCreateHost:
         assert "make_include_object" in env_py
         assert "for mod in modules:" not in env_py
 
+    async def test_main_py_loads_dotenv_before_settings(self, tmp_path):
+        """Regression for #158: scaffolded main.py must populate ``os.environ``
+        from ``.env`` *before* ``Settings`` is imported, otherwise framework
+        code reading ``os.environ`` directly (e.g. users.bootstrap's dotenv
+        fallback under uvicorn launched from ``host/``) silently misses values
+        that pydantic-settings would have picked up.
+        """
+        from simple_module_cli.scaffolding import create_host
+
+        dest = tmp_path / "demo"
+        create_host(dest, name="demo", modules=[])
+        main_py = (dest / "main.py").read_text(encoding="utf-8")
+
+        assert "load_dotenv_into_environ" in main_py
+        assert "os.chdir" in main_py
+        # The load_dotenv call must precede the first ``Settings`` import so
+        # ``BootstrapSettings``' ``env_file=".env"`` lookup and any direct
+        # ``os.environ.get(...)`` reads see the same view of the environment.
+        dotenv_idx = main_py.index("load_dotenv_into_environ(")
+        settings_import_idx = main_py.index("from simple_module_hosting import")
+        assert dotenv_idx < settings_import_idx
+
     async def test_cli_create_host_runs_end_to_end(self, tmp_path):
         """The Click `smpy create-host` command produces a working scaffold."""
         from simple_module_cli.cli import app
@@ -171,3 +193,77 @@ class TestCreateHost:
         assert "simple_module_dashboard" in (tmp_path / "out" / "pyproject.toml").read_text(
             encoding="utf-8"
         )
+
+    async def test_scaffold_vite_config_includes_node_paths_fallback(self, tmp_path):
+        """vite.config.ts must seed optimizeDeps.esbuildOptions.nodePaths
+        with the workspace node_modules so esbuild's scan-imports pass can
+        resolve cross-package bare imports from module pages whose importers
+        sit outside the host's client_app (e.g. wheel-installed modules).
+
+        Regression test for GitHub issue #152.
+        """
+        from simple_module_cli.scaffolding import create_host
+
+        dest = tmp_path / "demo"
+        create_host(name="demo", dest=dest, modules=[])
+
+        vite_config = (dest / "client_app" / "vite.config.ts").read_text(encoding="utf-8")
+
+        # The scanner fallback must be configured under optimizeDeps so it
+        # applies to both dev pre-bundling and `vite build`'s pre-bundle pass.
+        assert "esbuildOptions" in vite_config, (
+            "vite.config.ts must configure optimizeDeps.esbuildOptions"
+        )
+        assert "nodePaths" in vite_config, (
+            "vite.config.ts must seed optimizeDeps.esbuildOptions.nodePaths "
+            "with the workspace node_modules (GH issue #152)."
+        )
+        # The seeded path must reference fsRoot — the dir that contains the
+        # hoisted node_modules — not a hardcoded literal that breaks in
+        # flat-vs-workspace layouts.
+        assert "fsRoot" in vite_config, (
+            "nodePaths must reference fsRoot (not a hardcoded literal) so the "
+            "fallback works in both flat and workspace layouts (GH issue #152)."
+        )
+        assert "node_modules" in vite_config, (
+            "nodePaths entry must include 'node_modules' (GH issue #152)."
+        )
+
+    async def test_scaffold_vite_resolver_does_not_skip_workspace_modules(self, tmp_path):
+        """The moduleBareImportResolver plugin must NOT short-circuit on
+        ``fsRootPrefix`` containment.
+
+        In an npm-workspaces scaffold, ``fsRoot`` resolves to the workspace
+        root, which means workspace-member modules at ``modules/<name>/`` sit
+        *under* ``fsRoot``. An early-return gating on ``fsRootPrefix`` skips
+        them, leaving cross-package bare imports (`maplibre-gl`, `pmtiles`,
+        ...) unresolved during dev-mode resolveId.
+
+        The plugin should guard only on the module-pages prefix set — the
+        condition that actually identifies module-page importers regardless of
+        whether they sit inside or outside ``fsRoot``.
+
+        Regression test for GitHub issue #156.
+        """
+        from simple_module_cli.scaffolding import create_host
+
+        dest = tmp_path / "demo"
+        create_host(name="demo", dest=dest, modules=[])
+
+        vite_config = (dest / "client_app" / "vite.config.ts").read_text(encoding="utf-8")
+
+        # The resolver must still exist — the fix shouldn't remove the plugin.
+        assert "moduleBareImportResolver" in vite_config, (
+            "vite.config.ts must register the cross-package bare-import resolver."
+        )
+        # The buggy early-return must be gone (GH issue #156).
+        assert "startsWith(fsRootPrefix)" not in vite_config, (
+            "vite.config.ts must not early-return on fsRootPrefix containment — "
+            "in npm-workspaces mode workspace-member module pages live under "
+            "fsRoot and would be incorrectly skipped (GH issue #156)."
+        )
+        # The workspace-root re-resolution must still run.
+        assert "fakeWorkspaceImporter" in vite_config, (
+            "vite.config.ts must re-resolve unresolved bare imports against the "
+            "workspace root so hoisted node_modules wins (GH issue #156)."
+        )

simple_module_cli-0.0.13/simple_module_cli/templates/host/main.py

@@ -1,30 +0,0 @@
-"""Host application entry point.
-
-This file was generated by `smpy create-host`. Modules are discovered at boot
-via entry_points; add them to this host's pyproject.toml to install them.
-"""
-
-from simple_module_hosting import Settings, create_app
-from simple_module_hosting.logging import setup_logging
-
-from routes import router as host_router
-
-settings = Settings()
-
-setup_logging(
-    level=settings.log_level,
-    json_format=settings.log_format == "json",
-)
-
-app = create_app(settings)
-app.include_router(host_router)
-
-if __name__ == "__main__":
-    import uvicorn
-
-    uvicorn.run(
-        "main:app",
-        host="0.0.0.0",
-        port=8000,
-        reload=settings.is_development,
-    )