ndsdk-cli 1.0.0__tar.gz

ndsdk_cli-1.0.0/MANIFEST.in

@@ -0,0 +1,6 @@
+recursive-include ndsdk/templates *.j2
+recursive-include ndsdk/packages *.j2 *.yaml
+recursive-include ndsdk/templates *.j2
+include ndsdk/*.yaml
+include ndsdk/*.txt
+global-exclude __pycache__ *.py[cod] .DS_Store

ndsdk_cli-1.0.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: ndsdk-cli
+Version: 1.0.0
+Summary: ND-SDK metadata-driven Template generator
+Author-email: Hari Hara Sudhan P <harihara.sudhan@novacisinnovations.com>
+License: Proprietary
+Keywords: code-generation,csharp,microservice,scaffolding,yaml
+Description-Content-Type: text/markdown
+Requires-Dist: click>=8.1
+Requires-Dist: PyYAML>=6.0
+Requires-Dist: Jinja2>=3.1

ndsdk_cli-1.0.0/ndsdk/__init__.py

@@ -0,0 +1,3 @@
+"""ND-SDK CLI — metadata-driven scaffolding generator for ASP.NET C# projects."""
+
+__version__ = "0.1.0"

ndsdk_cli-1.0.0/ndsdk/config_normalizer.py

@@ -0,0 +1,306 @@
+"""Compatibility normalisation for ND-SDK config files.
+
+The generator internally works with one canonical provider shape. Public config
+should describe every external capability the same way:
+
+* ``integrations`` describe external resources (database, storage, queue, API, ...)
+* ``providers`` describe generated adapter classes
+* ``providers[].methods`` describe provider operations using a common method shape
+* ``packages`` describe capabilities that must be injected into the generated app
+
+Older database-first keys are still accepted for compatibility, but are folded
+into the same common shape instead of creating a separate public database model.
+"""
+
+from __future__ import annotations
+
+import copy
+from typing import Any
+
+
+_RELATIONAL_PROVIDERS = {
+    "sqlserver",
+    "sql_server",
+    "mssql",
+    "postgres",
+    "postgresql",
+    "mysql",
+    "oracle",
+    "snowflake",
+}
+_NON_RELATIONAL_PROVIDERS = {
+    "cassandra",
+    "dynamodb",
+    "mongodb",
+    "cosmosdb",
+    "cosmos",
+    "redis",
+    "elasticsearch",
+}
+_DB_METHOD_KEYS = {
+    "stored_procedure",
+    "target",
+    "table",
+    "inputs",
+    "parameters",
+    "cursors",
+}
+_METHOD_ALIAS_KEYS = {"database", "entity"}
+
+
+def normalize_config(config: dict[str, Any] | None) -> dict[str, Any]:
+    """Return a deep-copied canonical config.
+
+    Supported compatibility aliases:
+    * ``defaults.observability`` -> ``defaults.packages.observability``
+    * old ``framework_packages`` blocks -> public ``packages`` blocks
+    * old ``service.database`` -> synthetic database integration only when no
+      equivalent integration exists
+    * ``endpoints[].request_dto`` / ``response_dto`` are mirrored into the older
+      request/response model fields only when those fields are absent
+    * ``providers[].methods[].entity`` -> ``input_entity``
+    * ``providers[].methods[].database`` and top-level DB method fields ->
+      ``providers[].methods[].settings``
+    """
+
+    if not isinstance(config, dict):
+        return {}
+    out = copy.deepcopy(config or {})
+    _normalize_defaults(out)
+    for svc in out.get("services", []) or []:
+        _normalize_service(svc)
+    return out
+
+
+def _normalize_defaults(config: dict[str, Any]) -> None:
+    defaults = config.setdefault("defaults", {})
+
+    packages = _merge_package_blocks(defaults.get("framework_packages"), defaults.get("packages"))
+    defaults.pop("framework_packages", None)
+    defaults["packages"] = packages
+
+    observability = defaults.get("observability")
+    if isinstance(observability, dict):
+        current = packages.get("observability")
+        if isinstance(current, dict):
+            packages["observability"] = {**observability, **current}
+        else:
+            packages["observability"] = {"enabled": observability.get("enabled", True), **observability}
+    elif observability is True:
+        packages.setdefault("observability", {"enabled": True})
+    elif observability is False:
+        packages.setdefault("observability", {"enabled": False})
+
+
+def _merge_package_blocks(*blocks: Any) -> dict[str, Any]:
+    """Normalize package declarations to one ``{key: settings}`` map.
+
+    Supported public shapes:
+
+    ``packages: { observability: { enabled: true } }``
+    ``packages: [ { name: observability, enabled: true } ]``
+    ``packages: [ observability ]``
+    """
+    merged: dict[str, Any] = {}
+    for block in blocks:
+        if not block:
+            continue
+        if isinstance(block, dict):
+            merged.update(block)
+            continue
+        if isinstance(block, list):
+            for item in block:
+                if isinstance(item, str):
+                    merged[item] = {"enabled": True}
+                elif isinstance(item, dict):
+                    key = item.get("name") or item.get("key") or item.get("package")
+                    if key:
+                        settings = {k: v for k, v in item.items() if k not in {"name", "key", "package"}}
+                        merged[str(key)] = settings or {"enabled": True}
+    return merged
+
+
+def _normalize_service(svc: dict[str, Any]) -> None:
+    svc["packages"] = _merge_package_blocks(svc.get("framework_packages"), svc.get("packages"))
+    svc.pop("framework_packages", None)
+
+    _normalize_integrations(svc)
+    _normalize_legacy_database_block(svc)
+
+    integrations = svc.get("integrations", []) or []
+    integration_by_name = {
+        i.get("name"): i for i in integrations if isinstance(i, dict) and i.get("name")
+    }
+
+    for ep in svc.get("endpoints", []) or []:
+        if "request_dto" in ep and "request_model" not in ep:
+            ep["request_model"] = ep["request_dto"]
+        if "response_dto" in ep and "response_model" not in ep:
+            ep["response_model"] = ep["response_dto"]
+        ep.setdefault(
+            "consumes",
+            "application/json" if str(ep.get("http_method", "GET")).upper() in {"POST", "PUT", "PATCH"} else "",
+        )
+
+    for prov in svc.get("providers", []) or []:
+        integration_name = prov.get("integration")
+        integration = integration_by_name.get(integration_name)
+        provider_kind = _provider_kind(prov, integration)
+        prov["kind"] = provider_kind
+
+        # Backward compatibility: old `db: true` providers become database kind.
+        if prov.get("db") is True:
+            prov["kind"] = "database"
+            provider_kind = "database"
+        prov.pop("db", None)
+
+        if not prov.get("integration") and provider_kind == "database":
+            db_integration = next(
+                (i for i in integrations if isinstance(i, dict) and str(i.get("kind", "")).lower() == "database"),
+                None,
+            )
+            if db_integration and db_integration.get("name"):
+                prov["integration"] = db_integration["name"]
+                integration_name = prov["integration"]
+                integration = db_integration
+
+        for method in prov.get("methods", []) or []:
+            _normalize_provider_method(method, provider_kind, integration_name)
+
+
+def _normalize_integrations(svc: dict[str, Any]) -> None:
+    integrations = svc.get("integrations")
+    if not isinstance(integrations, list):
+        integrations = []
+        svc["integrations"] = integrations
+
+    for integration in integrations:
+        if not isinstance(integration, dict):
+            continue
+        integration["kind"] = str(integration.get("kind") or "custom").lower()
+        settings = integration.get("settings") if isinstance(integration.get("settings"), dict) else {}
+
+        # Keep all provider-specific details under the common `settings` object.
+        for key in ("database_type", "connection_string_name", "container_name", "queue_name", "base_url_config_key"):
+            if key in integration and key not in settings:
+                settings[key] = integration.pop(key)
+        if "type" in integration and integration["kind"] == "database" and "database_type" not in settings:
+            settings["database_type"] = integration.pop("type")
+
+        provider = integration.get("provider") or integration.get("store")
+        if provider and "provider" not in integration:
+            integration["provider"] = provider
+        integration.pop("store", None)
+
+        if integration["kind"] == "database" and "database_type" not in settings:
+            settings["database_type"] = _infer_db_type(str(provider or ""))
+
+        integration["settings"] = settings
+
+
+def _normalize_legacy_database_block(svc: dict[str, Any]) -> None:
+    """Fold an old service.database block into a database integration.
+
+    The normalized public copy should use integrations/providers/settings. The
+    legacy block is removed after an equivalent integration is present.
+    """
+    db = svc.get("database")
+    if not isinstance(db, dict):
+        return
+
+    integrations = svc.setdefault("integrations", [])
+    has_database_integration = any(
+        isinstance(i, dict) and str(i.get("kind", "")).lower() == "database"
+        for i in integrations
+    )
+    if not has_database_integration:
+        provider = db.get("provider") or db.get("store")
+        integrations.append({
+            "name": db.get("integration") or "database",
+            "kind": "database",
+            "provider": provider,
+            "settings": {
+                "database_type": db.get("type") or _infer_db_type(str(provider or "")),
+                **({"connection_string_name": db["connection_string_name"]} if db.get("connection_string_name") else {}),
+            },
+        })
+    svc.pop("database", None)
+    _normalize_integrations(svc)
+
+
+def _provider_kind(prov: dict[str, Any], integration: dict[str, Any] | None) -> str:
+    if prov.get("kind"):
+        return str(prov["kind"]).lower()
+    if integration and integration.get("kind"):
+        return str(integration["kind"]).lower()
+    if prov.get("db") is True or isinstance(prov.get("database"), dict):
+        return "database"
+
+    # Compatibility: older configs expressed database providers by putting
+    # database-shaped method fields directly on provider methods. Treat that as
+    # database, then normalize those fields into method.settings.
+    for method in prov.get("methods", []) or []:
+        if not isinstance(method, dict):
+            continue
+        if isinstance(method.get("database"), dict):
+            return "database"
+        if method.get("kind") in {"relational", "non_relational"}:
+            return "database"
+        if any(key in method for key in _DB_METHOD_KEYS):
+            return "database"
+    return "custom"
+
+
+def _normalize_provider_method(method: dict[str, Any], provider_kind: str, integration_name: str | None) -> None:
+    if method.get("entity") and not method.get("input_entity"):
+        method["input_entity"] = method["entity"]
+    method.pop("entity", None)
+
+    settings: dict[str, Any] = {}
+    if isinstance(method.get("settings"), dict):
+        settings.update(method["settings"])
+
+    # Old database method block is now just provider-specific method settings.
+    db_block = method.get("database") if isinstance(method.get("database"), dict) else {}
+    settings = {**db_block, **settings}
+    method.pop("database", None)
+
+    for key in list(_DB_METHOD_KEYS):
+        if key in method and key not in settings:
+            settings[key] = method.pop(key)
+
+    op = str(method.get("operation", "") or "").strip()
+    if op:
+        method["operation"] = _normalize_operation(op)
+    elif provider_kind == "database":
+        if settings.get("stored_procedure"):
+            method["operation"] = "stored_procedure"
+        else:
+            method["operation"] = "query"
+
+    if provider_kind == "database" and method.get("kind") in {"relational", "non_relational"}:
+        settings.setdefault("method_type", method.pop("kind"))
+
+    method["settings"] = settings
+    method.setdefault("integration", integration_name)
+
+    for alias in _METHOD_ALIAS_KEYS:
+        method.pop(alias, None)
+
+
+def _normalize_operation(op: str) -> str:
+    normalized = op.strip().replace(" ", "_").replace("-", "_").lower()
+    if normalized in {"storedprocedure", "stored_proc", "stored_procedure", "sp"}:
+        return "stored_procedure"
+    if normalized in {"query", "getresults", "get_results"}:
+        return "query"
+    return normalized
+
+
+def _infer_db_type(provider: str) -> str:
+    p = provider.strip().lower()
+    if p in _RELATIONAL_PROVIDERS:
+        return "relational"
+    if p in _NON_RELATIONAL_PROVIDERS:
+        return "non_relational"
+    return "non_relational"

ndsdk_cli-1.0.0/ndsdk/generators/__init__.py

@@ -0,0 +1,8 @@
+"""Generators package — manifest-driven engine + variant discovery."""
+
+from .engine import available_variants, get_generator, resolve_variant  # noqa: F401
+
+
+def available_architectures() -> list[str]:
+    """Back-compat: 'type/style' strings."""
+    return [f"{t}/{s}" for t, s in available_variants()]

ndsdk_cli-1.0.0/ndsdk/generators/base.py

@@ -0,0 +1,93 @@
+"""Low-level generator helpers: Jinja env, file IO, namespace + nuget resolution.
+
+Shared by the manifest engine. No architecture-specific logic lives here.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from jinja2 import ChoiceLoader, Environment, FileSystemLoader, StrictUndefined
+
+from .. import naming
+
+TEMPLATES_DIR = Path(__file__).parent.parent / "templates"
+COMMON_DIR = TEMPLATES_DIR / "_common"
+
+
+def make_env(variant_dir: Path) -> Environment:
+    """Jinja env that searches the variant folder first, then _common."""
+    env = Environment(
+        loader=ChoiceLoader([
+            FileSystemLoader(str(variant_dir)),
+            FileSystemLoader(str(COMMON_DIR)),
+        ]),
+        trim_blocks=True,
+        lstrip_blocks=True,
+        keep_trailing_newline=True,
+        undefined=StrictUndefined,
+    )
+    naming.register_filters(env)
+    return env
+
+
+def write_file(path: Path, content: str, *, owner: str = "framework") -> tuple[Path, bool]:
+    """Write a file. Returns (path, written).
+
+    ``owner='user'`` files are written once and never overwritten, so business
+    logic survives regeneration after a framework/controller change.
+    """
+    if owner == "user" and path.exists():
+        return path, False
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if not content.endswith("\n"):
+        content += "\n"
+    path.write_text(content, encoding="utf-8")
+    return path, True
+
+
+def resolve_namespaces(ns_templates: dict[str, str], base_ns: str) -> dict[str, str]:
+    """Resolve a layout's namespace map (e.g. ``{ns}.Domain.Entities``) against a
+    service's base namespace."""
+    out = {"base": base_ns}
+    for key, tmpl in (ns_templates or {}).items():
+        out[key] = tmpl.format(ns=base_ns)
+    return out
+
+
+def resolve_nuget_refs(
+    package_refs: list,
+    *,
+    config_versions: dict[str, str],
+    version_strategy: str = "floating",
+) -> list[dict]:
+    """De-duplicate NuGet refs and apply version precedence.
+
+    Precedence (highest first):
+      1. config ``package_versions[name]`` override
+      2. explicit/default version from package or layout YAML
+      3. ``nuget_version_strategy`` fallback
+
+    This keeps package YAML versions as shipped defaults, not hardcoded locks.
+    """
+    resolved: dict[str, str] = {}
+    for ref in package_refs:
+        if isinstance(ref, str):
+            name, version = (ref.split("@", 1) + [""])[:2]
+            name, version = name.strip(), version.strip()
+        else:
+            name = str(ref.get("name"))
+            version = str(ref.get("version", "") or "")
+        if name in config_versions:
+            version = str(config_versions[name])
+        # later refs override earlier (service overrides defaults), while the
+        # config-level package_versions override remains authoritative.
+        resolved[name] = version
+
+    out = []
+    for name, version in resolved.items():
+        if not version:
+            version = "*" if version_strategy == "floating" else None
+        out.append({"name": name, "version": version})
+    return out