ndsdk-cli 1.0.0__py3-none-any.whl

ndsdk/validators.py

@@ -0,0 +1,213 @@
+"""Validation for the ND-SDK C# config schema."""
+
+from __future__ import annotations
+
+from .config_normalizer import normalize_config
+from .generators import available_architectures
+from .registry import PackageRegistry
+
+VALID_METHODS = {"GET", "POST", "PUT", "DELETE", "PATCH"}
+VALID_DB_TYPES = {"relational", "non_relational"}
+VALID_DIRECTIONS = {"in", "out", "cursor"}
+
+
+class ConfigValidator:
+    def __init__(self):
+        self.packages = PackageRegistry()
+
+    def validate(self, config: dict) -> tuple[bool, list[str]]:
+        errors: list[str] = []
+        config = normalize_config(config)
+        if not isinstance(config, dict) or "project" not in config:
+            return False, ["Missing 'project' section"]
+
+        project = config["project"]
+        if not project.get("name"):
+            errors.append("Missing required field: project.name")
+
+        ptype = project.get("type", "microservice")
+        style = project.get("architecture", "layered")
+        variant = f"{ptype}/{style}"
+        if variant not in available_architectures():
+            errors.append(
+                f"Unknown architecture '{variant}'. "
+                f"Available: {', '.join(available_architectures())}"
+            )
+
+        errors += self._validate_packages(
+            config.get("defaults", {}).get("packages", {}),
+            "defaults.packages",
+        )
+
+        services = config.get("services")
+        if not services:
+            errors.append("At least one service must be defined under 'services'")
+        else:
+            names: set = set()
+            for i, svc in enumerate(services):
+                errors += self._validate_service(svc, i, names)
+        return len(errors) == 0, errors
+
+    def _validate_packages(self, pkg_cfg: dict, where: str) -> list[str]:
+        errors = []
+        available = set(self.packages.available())
+        for key in (pkg_cfg or {}):
+            if key not in available:
+                errors.append(
+                    f"{where}: unknown package '{key}'. "
+                    f"Available: {', '.join(sorted(available)) or '(none)'}"
+                )
+        return errors
+
+    def _validate_service(self, svc: dict, idx: int, names: set) -> list[str]:
+        errors = []
+        name = svc.get("name")
+        if not name:
+            return [f"services[{idx}]: missing 'name'"]
+        if name in names:
+            errors.append(f"services[{idx}]: duplicate service name '{name}'")
+        names.add(name)
+
+        errors += self._validate_packages(
+            svc.get("packages", {}), f"services.{name}.packages"
+        )
+
+        model_names = {m.get("name") for m in svc.get("models", [])}
+        dto_names = {d.get("name") for d in svc.get("dtos", [])}
+        entity_names = {e.get("name") for e in svc.get("entities", [])}
+        integrations = {
+            i.get("name"): i
+            for i in svc.get("integrations", []) or []
+            if isinstance(i, dict) and i.get("name")
+        }
+
+        errors += self._validate_integrations(svc, name)
+        errors += self._validate_endpoints(svc, name, model_names, dto_names)
+        errors += self._validate_providers(svc, name, integrations, entity_names)
+        return errors
+
+    def _validate_integrations(self, svc: dict, service_name: str) -> list[str]:
+        errors = []
+        seen: set[str] = set()
+        for ii, integration in enumerate(svc.get("integrations", []) or []):
+            label = f"services.{service_name}.integrations[{ii}]"
+            if not isinstance(integration, dict):
+                errors.append(f"{label}: integration must be an object")
+                continue
+            iname = integration.get("name")
+            if not iname:
+                errors.append(f"{label}: missing 'name'")
+            elif iname in seen:
+                errors.append(f"{label}: duplicate integration name '{iname}'")
+            else:
+                seen.add(iname)
+            if not integration.get("kind"):
+                errors.append(f"{label}: missing 'kind'")
+            if str(integration.get("kind", "")).lower() == "database":
+                settings = integration.get("settings") if isinstance(integration.get("settings"), dict) else {}
+                dbt = settings.get("database_type", "non_relational")
+                if dbt not in VALID_DB_TYPES:
+                    errors.append(
+                        f"{label}.settings.database_type/database.type '{dbt}' invalid "
+                        f"(expected one of {', '.join(sorted(VALID_DB_TYPES))})"
+                    )
+        return errors
+
+    def _validate_endpoints(self, svc: dict, service_name: str, model_names: set, dto_names: set) -> list[str]:
+        errors = []
+        ep_names: set = set()
+        for j, ep in enumerate(svc.get("endpoints", [])):
+            label = f"services.{service_name}.endpoints[{j}]"
+            if not ep.get("name"):
+                errors.append(f"{label}: missing 'name'")
+            elif ep["name"] in ep_names:
+                errors.append(f"{label}: duplicate endpoint name '{ep['name']}'")
+            else:
+                ep_names.add(ep["name"])
+            method = str(ep.get("http_method", "GET")).upper()
+            if method not in VALID_METHODS:
+                errors.append(f"{label}: invalid http_method '{method}'")
+            for ref_field in ("request_dto", "response_dto"):
+                ref = ep.get(ref_field)
+                if ref and ref not in dto_names:
+                    errors.append(
+                        f"{label}: {ref_field} '{ref}' not defined in services.{service_name}.dtos"
+                    )
+            for ref_field in ("request_model", "response_model"):
+                ref = ep.get(ref_field)
+                if ref and ref not in model_names and ref not in dto_names:
+                    errors.append(
+                        f"{label}: {ref_field} '{ref}' not defined in services.{service_name}.models or services.{service_name}.dtos"
+                    )
+        return errors
+
+    def _validate_providers(self, svc: dict, service_name: str, integrations: dict, entity_names: set) -> list[str]:
+        errors = []
+        for k, prov in enumerate(svc.get("providers", []) or []):
+            plabel = f"services.{service_name}.providers[{k}]"
+            if not prov.get("name"):
+                errors.append(f"{plabel}: missing 'name'")
+            integration = integrations.get(prov.get("integration"))
+            if prov.get("integration") and not integration:
+                errors.append(f"{plabel}: integration '{prov.get('integration')}' not defined in services.{service_name}.integrations")
+            provider_kind = str(prov.get("kind") or (integration or {}).get("kind") or "custom").lower()
+
+            for mi, m in enumerate(prov.get("methods", []) or []):
+                mlabel = f"{plabel}.methods[{mi}]"
+                if not m.get("name"):
+                    errors.append(f"{mlabel}: missing 'name'")
+                if not m.get("operation"):
+                    errors.append(f"{mlabel}: missing 'operation'")
+
+                input_entity = m.get("input_entity") or m.get("entity")
+                if input_entity and input_entity not in entity_names:
+                    errors.append(
+                        f"{mlabel}: input_entity '{input_entity}' not defined in services.{service_name}.entities"
+                    )
+                output_entity = m.get("output_entity")
+                if output_entity and output_entity not in entity_names:
+                    errors.append(
+                        f"{mlabel}: output_entity '{output_entity}' not defined in services.{service_name}.entities"
+                    )
+
+                if provider_kind == "database":
+                    errors += self._validate_database_method(m, mlabel)
+        return errors
+
+    def _validate_database_method(self, method: dict, label: str) -> list[str]:
+        errors = []
+        settings = method.get("settings") if isinstance(method.get("settings"), dict) else {}
+        # Compatibility when validator receives already-normalized or old shapes.
+        db_block = method.get("database") if isinstance(method.get("database"), dict) else {}
+        settings = {**db_block, **settings}
+        for key in ("stored_procedure", "target", "table", "inputs", "parameters"):
+            if key in method and key not in settings:
+                settings[key] = method[key]
+
+        method_type = settings.get("method_type") or method.get("kind")
+        if method_type and method_type not in VALID_DB_TYPES:
+            errors.append(f"{label}: invalid method_type '{method_type}'")
+
+        operation = str(method.get("operation", "")).lower()
+        if operation in {"storedprocedure", "stored_proc", "stored_procedure", "sp"}:
+            if not settings.get("stored_procedure") and not settings.get("target"):
+                errors.append(f"{label}: stored_procedure operation needs settings.stored_procedure or settings.target")
+        elif operation in {"query", "getresults", "get_results"}:
+            if not settings.get("table") and not settings.get("inputs") and not settings.get("target"):
+                errors.append(f"{label}: query operation needs settings.table, settings.inputs, or settings.target")
+
+        for pi, param in enumerate(settings.get("parameters", []) or []):
+            plabel = f"{label}.settings.parameters[{pi}]"
+            if not param.get("name"):
+                errors.append(f"{plabel}: missing 'name'")
+            d = param.get("direction", "in")
+            if d not in VALID_DIRECTIONS:
+                errors.append(
+                    f"{plabel}: invalid direction '{d}' "
+                    f"(expected {', '.join(sorted(VALID_DIRECTIONS))})"
+                )
+            if "size" in param and not isinstance(param.get("size"), int):
+                errors.append(f"{plabel}: 'size' must be an integer")
+            if d == "cursor" and not (param.get("cursor_name") or param.get("name")):
+                errors.append(f"{plabel}: cursor parameter needs 'cursor_name' or 'name'")
+        return errors

ndsdk_cli-1.0.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,51 @@
+ndsdk/__init__.py,sha256=DaMgQOu4LMF7-EsicjJ2dSuLaCIvhPZo8nQ67XUEdiU,107
+ndsdk/config_normalizer.py,sha256=xxO0oebjXu3_2qu2ztF3aY0pVM_AtpOB-4icojt4M7I,11532
+ndsdk/main.py,sha256=-l82D6_FpGcVB7x-CAfzTKRMap7ZZimFIo9w5Lj5Wdc,21827
+ndsdk/naming.py,sha256=YpGR3k0aF0-9Wiz9lxv__Zg26v33_mvXhq5q9JpwBp0,3332
+ndsdk/registry.py,sha256=vcGpbF4KaTBGAfEumxwg-M42f2HMpUdifG2BRnKb-5U,7271
+ndsdk/validators.py,sha256=Ti1h-_QlzWuTLHk2JdvLmU_46DOEFwwCLBSoapIV_0I,10136
+ndsdk/generators/__init__.py,sha256=FYwM29LgK-CSkmf0XXsiBeZT2L1K4EN8UAmPuoabcEo,307
+ndsdk/generators/base.py,sha256=iySl6iHh9C0K3S3S4ZR9mUTccw336fFArTeql_otxjU,3101
+ndsdk/generators/engine.py,sha256=X_pE912sV1thbIgrtNVJGknP6_iyq5AOEpi7FquY0Xs,32183
+ndsdk/packages/client_provider/Program.fragment.cs.j2,sha256=20odXlUkDsvRHStEQNe0Lhj5OYFlTs4FeXHzmKqA858,38
+ndsdk/packages/client_provider/appsettings.fragment.json.j2,sha256=jUQrmS_Ry6T2RJqSjGH3hXEyoMGNl7fs6a7gWXRjOPc,491
+ndsdk/packages/client_provider/package.yaml,sha256=jx1kkPicrzsN_Fi5Knflv_Ds23Ero3xv5Wddn8pJ-CY,418
+ndsdk/packages/db_provider/Program.fragment.cs.j2,sha256=qINRo0EY1ewMjoWGlyQvT5PpE0hnQrOgafSFtIO867c,157
+ndsdk/packages/db_provider/appsettings.fragment.json.j2,sha256=AaUS1zGWrRxMWWVsBj_KNNPy7WEgOOSI0pm9Tye6OqI,1195
+ndsdk/packages/db_provider/package.yaml,sha256=mysmCg6rvP519Qv2ZCDr9O8qwdsKMGl5HB0fxdk5DBU,5816
+ndsdk/packages/exception_handling/Program.app.fragment.cs.j2,sha256=TURXywQHee1jFpuFLv6cO8Fj5g7GPFSjNkZDnHvItfE,52
+ndsdk/packages/exception_handling/Program.fragment.cs.j2,sha256=f3BmbNY-HbuldoKixiy3CBySDPoSQh_qgGH2-gKyOHw,41
+ndsdk/packages/exception_handling/package.yaml,sha256=thjkfWgggkaalekhpi6umVks1yL9e6EmrvfASoVB79U,240
+ndsdk/packages/file_storage_azure/Program.fragment.cs.j2,sha256=pqnV9gUKRDMfqoLaGjqUkF9GYxoM71xqwmkzc4xqlEw,41
+ndsdk/packages/file_storage_azure/appsettings.fragment.json.j2,sha256=gz2VwOkL35SwiuM_UZe6AX1gQgprXbCVwHZ3SL5UhM8,136
+ndsdk/packages/file_storage_azure/package.yaml,sha256=d8H1XhBIap8hNwbLe_WFxoq7QUTqDvCiNrA5T-EtRTI,459
+ndsdk/packages/observability/Program.fragment.cs.j2,sha256=roghPhFKbJkajGNsX3WEyhYFZykbh7Xb7d2yhr0tvn8,107
+ndsdk/packages/observability/appsettings.fragment.json.j2,sha256=_RXiBMxu_GxUbKQKFZim0lBO5eSZVuK3jnjLiSAgLCU,1257
+ndsdk/packages/observability/package.yaml,sha256=CM3t6_3_7szLsEOr7ydoQh4Zyh1Wa9n-VmNDIXwkfYU,610
+ndsdk/templates/_common/BO.cs.j2,sha256=zr-bvzaZyDZUa_PADCyrFaTwIREc93P4Tm8yeeqGB5o,297
+ndsdk/templates/_common/Controller.cs.j2,sha256=xVs4a4Idz8zcgO1irTqFbCJEuK0eZp2rZk3vfSyWCVc,5030
+ndsdk/templates/_common/DbProviderBase.cs.j2,sha256=2efb1FRpWHFB-ru5XbbyGpUk5XyBmIaiKjy_gcPi4S0,1222
+ndsdk/templates/_common/Dockerfile.j2,sha256=zgSGbeuQBgBSpGzgbnje9N5Nx25eA0Clc2yry9909bY,468
+ndsdk/templates/_common/Dto.cs.j2,sha256=kedLzSIwlGZIWcDZCXIxW5GMJklPUtLlkjKVkasPqak,508
+ndsdk/templates/_common/Entity.cs.j2,sha256=TSt4im7mLvpK8zGEAaP0Q_bFbuS4AxCu8GgvJ3IjN28,539
+ndsdk/templates/_common/IService.cs.j2,sha256=n4_KbozXPSaXBoGqjX1eFE84Z5DdaD9YABwQfhg6C08,988
+ndsdk/templates/_common/Model.cs.j2,sha256=gvWF4vRgcqdxP860Cfrwv-OpNxophnY7GfX7y2AxLvs,519
+ndsdk/templates/_common/Provider.cs.j2,sha256=UNWS0ClPFHLKlznMHEcT69IGPpw2_SnbYycUqmlHVmA,7186
+ndsdk/templates/_common/ProviderBase.cs.j2,sha256=wSZNJ_u-1fUuDePnWSkw9BiE61-yxSZCnqEvgMHZiMU,326
+ndsdk/templates/_common/Service.cs.j2,sha256=yCrZ5UeV9x4p1ZVEHdt5DngK6PO0tCJYAgFjAbAbXm0,1752
+ndsdk/templates/_common/ServiceManager.cs.j2,sha256=_SFqTur_EefqKqy0Ziw6kpnpabHaEZP_9OKcfEWjTJ8,917
+ndsdk/templates/_common/Solution.sln.j2,sha256=e1YELg9n0cSlRyKBjS6bO09eJtgQ-gYrB-Q0tCjXmSc,933
+ndsdk/templates/_common/_csproj_refs.inc.j2,sha256=6FvtI5GyGBMuw22BVe2PB11MZb5X4y8gjuT6sSWhPqk,379
+ndsdk/templates/_common/launchSettings.json.j2,sha256=KXYX4kb5GCikPYwYW2h4Jw5YNEesyU81bRq9aToWy-A,538
+ndsdk/templates/microservice/clean/Api.csproj.j2,sha256=T7nqKw0qNfpsmC_s63CMmAYmoJt4Cqde9qXzuw4kXRs,363
+ndsdk/templates/microservice/clean/ClassLib.csproj.j2,sha256=gvYJRGDfrOR6-uTLQ_hzR92eJmuuntbHZrTGtug1_1Q,307
+ndsdk/templates/microservice/clean/Program.cs.j2,sha256=Uwra5ky6FV0WuqT8UMgdSjkgBsSFYYjvZ4rzENqFqV8,919
+ndsdk/templates/microservice/clean/layout.yaml,sha256=Al4b3PDTIgifxeyv31ad8b2TzpMvImxITIzJgPIusKk,3266
+ndsdk/templates/microservice/layered/Program.cs.j2,sha256=CfaLTmsHSaeSppWkR_lnsgOrDZ10EOoDk7oCoojMFpU,1767
+ndsdk/templates/microservice/layered/Project.csproj.j2,sha256=T7nqKw0qNfpsmC_s63CMmAYmoJt4Cqde9qXzuw4kXRs,363
+ndsdk/templates/microservice/layered/layout.yaml,sha256=Vhjk7PHPXazsmCgu9U0XOIBF_s43mwNGonUAvoslcMI,2520
+ndsdk_cli-1.0.0.dist-info/METADATA,sha256=HL2Z4bcgQ2oQv9S9DA5OUe4z_aM31nfdDwqpFr_LvgQ,393
+ndsdk_cli-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+ndsdk_cli-1.0.0.dist-info/entry_points.txt,sha256=0G9b-hgeriQ70sEriA_Q3VzqhzudekwLLT_0Fo1mINY,45
+ndsdk_cli-1.0.0.dist-info/top_level.txt,sha256=Pq37okmtVsM9QGJhaflyPxyojtMhrXKP9DCSndA_IFE,6
+ndsdk_cli-1.0.0.dist-info/RECORD,,

ndsdk_cli-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

ndsdk_cli-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ndsdk-cli = ndsdk.main:cli

ndsdk_cli-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+ndsdk