modwire 3.0.0__tar.gz → 3.1.1__tar.gz

{modwire-3.0.0 → modwire-3.1.1}/.github/workflows/release.yml

@@ -46,6 +46,15 @@ jobs:
             exit 1
           fi
 
+      - name: Use release tag as package version
+        if: github.event_name == 'release'
+        run: |
+          tag_name="${{ github.event.release.tag_name }}"
+          release_version="${tag_name#v}"
+
+          echo "MODWIRE_RELEASE_VERSION=$release_version" >> "$GITHUB_ENV"
+          echo "SETUPTOOLS_SCM_PRETEND_VERSION_FOR_MODWIRE=$release_version" >> "$GITHUB_ENV"
+
       - name: Set up Python
         uses: actions/setup-python@v5
         with:
@@ -90,12 +99,13 @@ jobs:
         if: github.event_name == 'release'
         run: |
           python - <<'PY'
+          import os
           import sys
           import zipfile
           from email.parser import Parser
           from pathlib import Path
 
-          expected_version = "${{ github.event.release.tag_name }}".removeprefix("v")
+          expected_version = os.environ["MODWIRE_RELEASE_VERSION"]
           wheels = sorted(Path("dist").glob("*.whl"))
           versions: dict[str, str] = {}
 

{modwire-3.0.0 → modwire-3.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modwire
-Version: 3.0.0
+Version: 3.1.1
 Summary: Map architecture boundaries and analyze extracted code maps.
 Author: Tomasz Szpak
 License-Expression: MIT
@@ -23,6 +23,7 @@ Classifier: Topic :: Software Development :: Quality Assurance
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: copier>=9.16.0
 Requires-Dist: modwire-extraction>=1.0.1
 Requires-Dist: pydantic>=2.8
 Provides-Extra: dev
@@ -113,6 +114,28 @@ Reports are Pydantic models, so they can be serialized with `model_dump()` or
 payload = report.model_dump(mode="json")
 ```
 
+## Module Generation
+
+`modwire.modules` can generate a module from any Copier template. A caller only
+needs to create a normal Copier template directory and pass it to
+`generate_module`.
+
+```python
+from pathlib import Path
+
+from modwire.modules import generate_module
+
+generate_module(
+    "billing",
+    Path("src/features"),
+    Path("templates/modwire-module"),
+    data={"service_name": "BillingService"},
+)
+```
+
+If no template path is provided, `generate_module` uses the bundled `layered`
+scaffolding. Bundled scaffoldings are packaged with the distribution wheel.
+
 ## Configuration
 
 Boundary tags classify source IDs. Flow rules then use those tags to detect

{modwire-3.0.0 → modwire-3.1.1}/README.md

@@ -79,6 +79,28 @@ Reports are Pydantic models, so they can be serialized with `model_dump()` or
 payload = report.model_dump(mode="json")
 ```
 
+## Module Generation
+
+`modwire.modules` can generate a module from any Copier template. A caller only
+needs to create a normal Copier template directory and pass it to
+`generate_module`.
+
+```python
+from pathlib import Path
+
+from modwire.modules import generate_module
+
+generate_module(
+    "billing",
+    Path("src/features"),
+    Path("templates/modwire-module"),
+    data={"service_name": "BillingService"},
+)
+```
+
+If no template path is provided, `generate_module` uses the bundled `layered`
+scaffolding. Bundled scaffoldings are packaged with the distribution wheel.
+
 ## Configuration
 
 Boundary tags classify source IDs. Flow rules then use those tags to detect

{modwire-3.0.0 → modwire-3.1.1}/pyproject.toml

@@ -33,6 +33,7 @@ classifiers = [
     "Topic :: Software Development :: Quality Assurance",
 ]
 dependencies = [
+    "copier>=9.16.0",
     "modwire-extraction>=1.0.1",
     "pydantic>=2.8",
 ]
@@ -72,6 +73,12 @@ cache-dir = ".dev/ruff_cache"
 package-dir = {"" = "src"}
 include-package-data = true
 
+[tool.setuptools.package-data]
+"modwire.modules" = [
+    "scaffoldings/*/copier.yml",
+    "scaffoldings/*/template/**/*.jinja",
+]
+
 [tool.setuptools.packages.find]
 where = ["src"]
 

{modwire-3.0.0 → modwire-3.1.1}/src/modwire/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '3.0.0'
-__version_tuple__ = version_tuple = (3, 0, 0)
+__version__ = version = '3.1.1'
+__version_tuple__ = version_tuple = (3, 1, 1)
 
-__commit_id__ = commit_id = 'g84d5eeaca'
+__commit_id__ = commit_id = None

modwire-3.1.1/src/modwire/modules/__init__.py

@@ -0,0 +1,3 @@
+from .generate import generate_module
+
+__all__ = ["generate_module"]

modwire-3.1.1/src/modwire/modules/generate.py

@@ -0,0 +1,74 @@
+from collections.abc import Iterator, Mapping
+from contextlib import contextmanager
+from importlib import resources
+from pathlib import Path
+from typing import Any
+
+import copier
+
+PathLike = str | Path
+
+
+@contextmanager
+def _bundled_scaffolding_path(scaffolding: str) -> Iterator[Path]:
+    scaffoldings = resources.files("modwire.modules") / "scaffoldings" / scaffolding
+    with resources.as_file(scaffoldings) as path:
+        yield path
+
+
+def generate_module(
+    module_name: str,
+    target_root: PathLike,
+    template_root: PathLike | None = None,
+    *,
+    scaffolding: str = "layered",
+    data: Mapping[str, Any] | None = None,
+    overwrite: bool = False,
+    skip_tasks: bool = True,
+) -> None:
+    if template_root is not None:
+        _run_copy(
+            Path(template_root),
+            target_root,
+            module_name,
+            data=data,
+            overwrite=overwrite,
+            skip_tasks=skip_tasks,
+        )
+        return
+
+    with _bundled_scaffolding_path(scaffolding) as resolved_template_root:
+        _run_copy(
+            resolved_template_root,
+            target_root,
+            module_name,
+            data=data,
+            overwrite=overwrite,
+            skip_tasks=skip_tasks,
+        )
+
+
+def _run_copy(
+    template_root: Path,
+    target_root: PathLike,
+    module_name: str,
+    *,
+    data: Mapping[str, Any] | None,
+    overwrite: bool,
+    skip_tasks: bool,
+) -> None:
+    resolved_template_root = template_root
+    if not resolved_template_root.exists():
+        raise FileNotFoundError(f"Copier template does not exist: {resolved_template_root}")
+
+    template_data = dict(data or {})
+    template_data["module_name"] = module_name
+
+    copier.run_copy(
+        str(resolved_template_root),
+        dst_path=target_root,
+        data=template_data,
+        defaults=True,
+        overwrite=overwrite,
+        skip_tasks=skip_tasks,
+    )

modwire-3.1.1/src/modwire/modules/scaffoldings/hexagonal/copier.yml

@@ -0,0 +1,38 @@
+_min_copier_version: "9.0.0"
+_templates_suffix: ".jinja"
+_subdirectory: template
+
+module_name:
+  type: str
+  default: sample_module
+  help: Importable module or package directory name.
+
+aggregate_name:
+  type: str
+  default: SampleAggregate
+  help: Domain aggregate class name.
+
+command_name:
+  type: str
+  default: CreateSample
+  help: Application command class name.
+
+service_name:
+  type: str
+  default: SampleService
+  help: Application service class name.
+
+repository_name:
+  type: str
+  default: SampleRepository
+  help: Repository port and adapter class suffix.
+
+controller_name:
+  type: str
+  default: SampleController
+  help: UI/controller class name.
+
+php_namespace:
+  type: str
+  default: App\\SampleModule
+  help: PHP namespace root for the generated classes.

modwire-3.1.1/src/modwire/modules/scaffoldings/hexagonal/template/php/src/Application/{{ command_name }}.php.jinja

@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace {{ php_namespace }}\Application;
+
+final readonly class {{ command_name }}
+{
+    public function __construct(
+        public string $id,
+        public string $name,
+    ) {
+    }
+}

modwire-3.1.1/src/modwire/modules/scaffoldings/hexagonal/template/php/src/Application/{{ service_name }}.php.jinja

@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace {{ php_namespace }}\Application;
+
+use {{ php_namespace }}\Domain\{{ aggregate_name }};
+use {{ php_namespace }}\Ports\{{ repository_name }};
+
+final class {{ service_name }}
+{
+    public function __construct(
+        private readonly {{ repository_name }} $repository,
+    ) {
+    }
+
+    public function handle({{ command_name }} $command): {{ aggregate_name }}
+    {
+        $aggregate = {{ aggregate_name }}::create($command->id, $command->name);
+        $this->repository->save($aggregate);
+
+        return $aggregate;
+    }
+}

modwire-3.1.1/src/modwire/modules/scaffoldings/hexagonal/template/php/src/Domain/{{ aggregate_name }}.php.jinja

@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace {{ php_namespace }}\Domain;
+
+final readonly class {{ aggregate_name }}
+{
+    private function __construct(
+        public string $id,
+        public string $name,
+    ) {
+    }
+
+    public static function create(string $id, string $name): self
+    {
+        if ($id === '') {
+            throw new \InvalidArgumentException('Aggregate id cannot be empty.');
+        }
+
+        if ($name === '') {
+            throw new \InvalidArgumentException('Aggregate name cannot be empty.');
+        }
+
+        return new self($id, $name);
+    }
+}

modwire-3.1.1/src/modwire/modules/scaffoldings/hexagonal/template/php/src/Infrastructure/InMemory{{ repository_name }}.php.jinja

@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace {{ php_namespace }}\Infrastructure;
+
+use {{ php_namespace }}\Domain\{{ aggregate_name }};
+use {{ php_namespace }}\Ports\{{ repository_name }};
+
+final class InMemory{{ repository_name }} implements {{ repository_name }}
+{
+    /** @var array<string, {{ aggregate_name }}> */
+    private array $items = [];
+
+    public function save({{ aggregate_name }} $aggregate): void
+    {
+        $this->items[$aggregate->id] = $aggregate;
+    }
+
+    public function get(string $id): ?{{ aggregate_name }}
+    {
+        return $this->items[$id] ?? null;
+    }
+}

modwire-3.1.1/src/modwire/modules/scaffoldings/hexagonal/template/php/src/Ports/{{ repository_name }}.php.jinja

@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace {{ php_namespace }}\Ports;
+
+use {{ php_namespace }}\Domain\{{ aggregate_name }};
+
+interface {{ repository_name }}
+{
+    public function save({{ aggregate_name }} $aggregate): void;
+
+    public function get(string $id): ?{{ aggregate_name }};
+}

modwire-3.1.1/src/modwire/modules/scaffoldings/hexagonal/template/php/src/Ui/{{ controller_name }}.php.jinja

@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace {{ php_namespace }}\Ui;
+
+use {{ php_namespace }}\Application\{{ command_name }};
+use {{ php_namespace }}\Application\{{ service_name }};
+
+final class {{ controller_name }}
+{
+    public function __construct(
+        private readonly {{ service_name }} $service,
+    ) {
+    }
+
+    /** @return array{id: string, name: string} */
+    public function create(string $id, string $name): array
+    {
+        $aggregate = $this->service->handle(new {{ command_name }}($id, $name));
+
+        return [
+            'id' => $aggregate->id,
+            'name' => $aggregate->name,
+        ];
+    }
+}

modwire-3.1.1/src/modwire/modules/scaffoldings/hexagonal/template/python/{{ module_name }}/__init__.py.jinja

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from . import application, domain, infrastructure, ports, ui
+
+__all__ = ["application", "domain", "infrastructure", "ports", "ui"]

modwire-3.1.1/src/modwire/modules/scaffoldings/hexagonal/template/python/{{ module_name }}/application.py.jinja

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from . import domain, ports
+
+
+class {{ command_name }}:
+    def __init__(self, aggregate_id: str, name: str) -> None:
+        self.aggregate_id = aggregate_id
+        self.name = name
+
+
+class {{ service_name }}:
+    def __init__(self, repository: ports.{{ repository_name }}) -> None:
+        self._repository = repository
+
+    def handle(self, command: {{ command_name }}) -> domain.{{ aggregate_name }}:
+        aggregate = domain.{{ aggregate_name }}.create(command.aggregate_id, command.name)
+        self._repository.save(aggregate)
+        return aggregate
+
+
+__all__ = ["{{ command_name }}", "{{ service_name }}"]

modwire-3.1.1/src/modwire/modules/scaffoldings/hexagonal/template/python/{{ module_name }}/domain.py.jinja

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class {{ aggregate_name }}:
+    aggregate_id: str
+    name: str
+
+    @classmethod
+    def create(cls, aggregate_id: str, name: str) -> "{{ aggregate_name }}":
+        if not aggregate_id:
+            raise ValueError("Aggregate id cannot be empty")
+        if not name:
+            raise ValueError("Aggregate name cannot be empty")
+        return cls(aggregate_id=aggregate_id, name=name)
+
+
+__all__ = ["{{ aggregate_name }}"]

modwire-3.1.1/src/modwire/modules/scaffoldings/hexagonal/template/python/{{ module_name }}/infrastructure.py.jinja

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from . import domain
+
+
+class InMemory{{ repository_name }}:
+    def __init__(self) -> None:
+        self._items: dict[str, domain.{{ aggregate_name }}] = {}
+
+    def save(self, aggregate: domain.{{ aggregate_name }}) -> None:
+        self._items[aggregate.aggregate_id] = aggregate
+
+    def get(self, aggregate_id: str) -> domain.{{ aggregate_name }} | None:
+        return self._items.get(aggregate_id)
+
+
+__all__ = ["InMemory{{ repository_name }}"]

modwire-3.1.1/src/modwire/modules/scaffoldings/hexagonal/template/python/{{ module_name }}/ports.py.jinja

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from typing import Protocol
+
+from . import domain
+
+
+class {{ repository_name }}(Protocol):
+    def save(self, aggregate: domain.{{ aggregate_name }}) -> None:
+        raise NotImplementedError
+
+    def get(self, aggregate_id: str) -> domain.{{ aggregate_name }} | None:
+        raise NotImplementedError
+
+
+__all__ = ["{{ repository_name }}"]

modwire-3.1.1/src/modwire/modules/scaffoldings/hexagonal/template/python/{{ module_name }}/ui.py.jinja

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from . import application, infrastructure
+
+
+class {{ controller_name }}:
+    def __init__(self, service: application.{{ service_name }}) -> None:
+        self._service = service
+
+    def create(self, aggregate_id: str, name: str) -> dict[str, str]:
+        aggregate = self._service.handle(application.{{ command_name }}(aggregate_id, name))
+        return {"id": aggregate.aggregate_id, "name": aggregate.name}
+
+
+def bootstrap() -> {{ controller_name }}:
+    repository = infrastructure.InMemory{{ repository_name }}()
+    service = application.{{ service_name }}(repository)
+    return {{ controller_name }}(service)
+
+
+__all__ = ["{{ controller_name }}", "bootstrap"]

modwire-3.1.1/src/modwire/modules/scaffoldings/hexagonal/template/typescript/{{ module_name }}/application.ts.jinja

@@ -0,0 +1,20 @@
+import { {{ aggregate_name }} } from "./domain";
+import { {{ repository_name }} } from "./ports";
+
+export class {{ command_name }} {
+  constructor(
+    public readonly aggregateId: string,
+    public readonly name: string,
+  ) {}
+}
+
+export class {{ service_name }} {
+  constructor(private readonly repository: {{ repository_name }}) {}
+
+  handle(command: {{ command_name }}): {{ aggregate_name }} {
+    const aggregate = {{ aggregate_name }}.create(command.aggregateId, command.name);
+    this.repository.save(aggregate);
+
+    return aggregate;
+  }
+}

modwire-3.1.1/src/modwire/modules/scaffoldings/hexagonal/template/typescript/{{ module_name }}/domain.ts.jinja

@@ -0,0 +1,18 @@
+export class {{ aggregate_name }} {
+  private constructor(
+    public readonly aggregateId: string,
+    public readonly name: string,
+  ) {}
+
+  static create(aggregateId: string, name: string): {{ aggregate_name }} {
+    if (aggregateId.length === 0) {
+      throw new Error("Aggregate id cannot be empty.");
+    }
+
+    if (name.length === 0) {
+      throw new Error("Aggregate name cannot be empty.");
+    }
+
+    return new {{ aggregate_name }}(aggregateId, name);
+  }
+}

modwire-3.1.1/src/modwire/modules/scaffoldings/hexagonal/template/typescript/{{ module_name }}/infrastructure.ts.jinja

@@ -0,0 +1,14 @@
+import { {{ aggregate_name }} } from "./domain";
+import { {{ repository_name }} } from "./ports";
+
+export class InMemory{{ repository_name }} implements {{ repository_name }} {
+  private readonly items = new Map<string, {{ aggregate_name }}>();
+
+  save(aggregate: {{ aggregate_name }}): void {
+    this.items.set(aggregate.aggregateId, aggregate);
+  }
+
+  get(aggregateId: string): {{ aggregate_name }} | undefined {
+    return this.items.get(aggregateId);
+  }
+}

modwire-3.1.1/src/modwire/modules/scaffoldings/hexagonal/template/typescript/{{ module_name }}/ports.ts.jinja

@@ -0,0 +1,6 @@
+import { {{ aggregate_name }} } from "./domain";
+
+export interface {{ repository_name }} {
+  save(aggregate: {{ aggregate_name }}): void;
+  get(aggregateId: string): {{ aggregate_name }} | undefined;
+}

modwire-3.1.1/src/modwire/modules/scaffoldings/hexagonal/template/typescript/{{ module_name }}/ui.ts.jinja

@@ -0,0 +1,19 @@
+import { {{ command_name }}, {{ service_name }} } from "./application";
+import { InMemory{{ repository_name }} } from "./infrastructure";
+
+export class {{ controller_name }} {
+  constructor(private readonly service: {{ service_name }}) {}
+
+  create(aggregateId: string, name: string): { id: string; name: string } {
+    const aggregate = this.service.handle(new {{ command_name }}(aggregateId, name));
+
+    return { id: aggregate.aggregateId, name: aggregate.name };
+  }
+}
+
+export function bootstrap(): {{ controller_name }} {
+  const repository = new InMemory{{ repository_name }}();
+  const service = new {{ service_name }}(repository);
+
+  return new {{ controller_name }}(service);
+}

modwire-3.1.1/src/modwire/modules/scaffoldings/layered/copier.yml

@@ -0,0 +1,23 @@
+_min_copier_version: "9.0.0"
+_templates_suffix: ".jinja"
+_subdirectory: template
+
+module_name:
+  type: str
+  default: sample_package
+  help: Importable package name that will own the four layer files.
+
+model_name:
+  type: str
+  default: SampleItem
+  help: Pydantic domain model class name.
+
+repository_name:
+  type: str
+  default: SampleRepository
+  help: Infrastructure repository class name.
+
+service_name:
+  type: str
+  default: SampleApplication
+  help: Application service class name.

modwire-3.1.1/src/modwire/modules/scaffoldings/layered/template/{{ module_name }}/application.py.jinja

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from . import domain, infrastructure
+
+
+class {{ service_name }}:
+    def __init__(self, repository: infrastructure.{{ repository_name }}) -> None:
+        self._repository = repository
+
+    def handle(self, name: str) -> domain.{{ model_name }}:
+        return self._repository.find(name)
+
+
+def bootstrap() -> {{ service_name }}:
+    return {{ service_name }}(infrastructure.{{ repository_name }}())
+
+
+__all__ = ["{{ service_name }}", "bootstrap"]

modwire-3.1.1/src/modwire/modules/scaffoldings/layered/template/{{ module_name }}/domain.py.jinja

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict
+
+
+class {{ model_name }}(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
+    name: str
+
+
+__all__ = ["{{ model_name }}"]

modwire-3.1.1/src/modwire/modules/scaffoldings/layered/template/{{ module_name }}/infrastructure.py.jinja

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from . import domain
+
+
+class {{ repository_name }}:
+    def find(self, name: str) -> domain.{{ model_name }}:
+        return domain.{{ model_name }}(name=name)
+
+
+__all__ = ["{{ repository_name }}"]