ndsdk-cli 1.0.0__py3-none-any.whl

ndsdk/packages/db_provider/appsettings.fragment.json.j2

@@ -0,0 +1,30 @@
+{
+  "DB_Provider": {
+    "RelationalDatabase": {
+      "Provider": "{{ settings.relational.provider }}",
+      "SqlServer": {
+        "SchemaName": "{{ settings.relational.schema_name }}",
+        "ConnectionString": "{{ settings.relational.connection_string }}"
+      }
+    },
+    "NonRelationalDatabase": {
+      "Provider": "{{ settings.non_relational.provider }}",
+      "Cassandra": {
+        "Keyspace": "{{ settings.non_relational.keyspace }}",
+        "ContactPoint": "{{ settings.non_relational.contact_point }}",
+        "Port": "{{ settings.non_relational.port }}",
+        "Username": "{{ settings.non_relational.username }}",
+        "Password": "{{ settings.non_relational.password }}",
+        "CoreConnectionsPerHost": "{{ settings.non_relational.core_connections_per_host }}",
+        "MaxConnectionsPerHost": "{{ settings.non_relational.max_connections_per_host }}",
+        "MaxRequestsPerConnection": "{{ settings.non_relational.max_requests_per_connection }}"
+      },
+      "RetryPolicy": {
+        "Postgres": {
+          "RetryCount": {{ settings.relational.retry_count }},
+          "RetryDelayMs": {{ settings.relational.retry_delay_ms }}
+        }
+      }
+    }
+  }
+}

ndsdk/packages/db_provider/package.yaml

@@ -0,0 +1,123 @@
+key: db_provider
+display_name: Data Access Manager
+description: ND.FW.DbAccessManager data-access manager with relational (rdb) and non-relational (ndb) backing stores.
+nuget:
+  - { name: ND.FW.DbAccessManager, version: 1.0.2 }
+defaults:
+  enabled: false
+  db_type: non_relational        # relational | non_relational
+  provider: cassandra            # concrete store (free text: sqlserver, postgres, cassandra, ...)
+  connection_string_name: DefaultConnection
+  facade_namespace: DataAccessLayer.Facade
+  types_namespace: DataAccessLayer.Models
+  facade_type: DbExternalizationFacade
+  request_type: ExternalizationRequest
+  response_type: ExternalizationResponse
+  dbtype_enum: DatabaseType
+  dbprovider_enum: DatabaseProvider
+
+  # --------------------------------------------------------------------------
+  # Backing-store connection settings.
+  # NOTE: no secrets are shipped here. Leave these blank and supply real values
+  # from the USER config (services[].packages.db_provider.relational.*) or, at
+  # runtime, from environment variables. .NET config layering means an env var
+  # named with the `__` hierarchy separator overrides the appsettings value, e.g.
+  #   DB_Provider__RelationalDatabase__SqlServer__ConnectionString=...
+  #   DB_Provider__RelationalDatabase__SqlServer__SchemaName=idp_proc
+  # so the schema name / connection string are never baked into code.
+  # --------------------------------------------------------------------------
+  relational:
+    provider: MSSQL
+    schema_name: ""                                             # supply via user config or env
+    # Config key the generated provider reads at runtime to resolve the schema.
+    # Fed by appsettings AND overridable by the env var of the same path.
+    schema_name_config_key: "DB_Provider:RelationalDatabase:SqlServer:SchemaName"
+    connection_string: ""                                       # supply via user config or env
+    retry_count: 3
+    retry_delay_ms: 1000
+  non_relational:
+    provider: cassandra
+    keyspace: ""
+    contact_point: ""
+    port: ""
+    username: ""
+    password: ""
+    core_connections_per_host: "1"
+    max_connections_per_host: "1"
+    max_requests_per_connection: "2048"
+
+  # --------------------------------------------------------------------------
+  # Database adapters. Adding a new engine is a config edit here — no Python
+  # change. The generator picks the adapter by store name (normalised), falling
+  # back to relational_default / non_relational_default by db_type.
+  #   di_register            -> Program.cs DI lines for this store
+  #   extended_context_type  -> the *ExtendedContext class the SP request uses
+  #   param_type_enum        -> C# type used for typed output params
+  #   extended_context_using -> namespace to import for that enum
+  #   default_param_type     -> param type when a parameter omits `type`
+  #   supports_cursors       -> emit CursorNames from cursor-direction params
+  # --------------------------------------------------------------------------
+  adapters:
+    mssql:
+      dbtype_enum_value: Relational
+      db_provider_enum: MSSQL
+      extended_context_type: MssqlExtendedContext
+      extended_context_using: System.Data
+      param_type_enum: SqlDbType
+      default_param_type: VarChar
+      output_params_field: OutputParameters      # name -> SqlDbType map on the ExtendedContext
+      output_sizes_field: OutputParameterSizes    # name -> int map (VARCHAR/NVARCHAR sizes)
+      supports_cursors: false
+      di_register:
+        - builder.Services.AddDBAccessLayer();
+        - builder.Services.AddSqlProvider(builder.Configuration);
+        - builder.Services.AddDbProviderServices();
+    postgres:
+      dbtype_enum_value: Relational
+      db_provider_enum: PostgreSQL
+      extended_context_type: PostgresExtendedContext
+      extended_context_using: NpgsqlTypes
+      param_type_enum: NpgsqlDbType
+      default_param_type: Varchar
+      output_params_field: UserTypes              # Postgres model names this UserTypes
+      cursor_field: CursorNames
+      supports_cursors: true
+      di_register:
+        - builder.Services.AddDBAccessLayer();
+        - builder.Services.AddSqlProvider(builder.Configuration);
+        - builder.Services.AddDbProviderServices();
+    cassandra:
+      dbtype_enum_value: NonRelational
+      db_provider_enum: Cassandra
+      di_register:
+        - builder.Services.AddDBAccessLayer();
+        - builder.Services.AddNoSqlProvider(builder.Configuration);
+        - builder.Services.AddDbProviderServices();
+    relational_default:
+      dbtype_enum_value: Relational
+      db_provider_enum: MSSQL
+      extended_context_type: MssqlExtendedContext
+      extended_context_using: System.Data
+      param_type_enum: SqlDbType
+      default_param_type: VarChar
+      output_params_field: OutputParameters
+      output_sizes_field: OutputParameterSizes
+      supports_cursors: false
+      di_register:
+        - builder.Services.AddDBAccessLayer();
+        - builder.Services.AddSqlProvider(builder.Configuration);
+        - builder.Services.AddDbProviderServices();
+    non_relational_default:
+      dbtype_enum_value: NonRelational
+      di_register:
+        - builder.Services.AddDBAccessLayer();
+        - builder.Services.AddNoSqlProvider(builder.Configuration);
+        - builder.Services.AddDbProviderServices();
+
+  dependencies:
+    - { type: DbExternalizationFacade, field: _dbFacade, role: facade }
+    - { type: IClientProvider, field: _clientProvider }
+interactive:
+  - { key: db_type, prompt: "Database type", choices: [non_relational, relational], default: non_relational }
+  - { key: provider, prompt: "Store / engine (e.g. cassandra, dynamodb, postgres, sqlserver)", default: cassandra }
+  - { key: connection_string_name, prompt: "Connection string name", default: DefaultConnection }

ndsdk/packages/exception_handling/Program.app.fragment.cs.j2

@@ -0,0 +1 @@
+app.UseMiddleware<NDExceptionHandlingMiddleware>();

ndsdk/packages/exception_handling/Program.fragment.cs.j2

@@ -0,0 +1 @@
+builder.Services.AddExceptionHandling();

ndsdk/packages/exception_handling/package.yaml

@@ -0,0 +1,7 @@
+key: exception_handling
+display_name: Exception Handling
+description: ND.FW.ExceptionHandling global exception middleware and problem-details responses.
+nuget:
+  - { name: ND.FW.ExceptionHandling, version: 0.0.5 }
+defaults:
+  enabled: true

ndsdk/packages/file_storage_azure/Program.fragment.cs.j2

@@ -0,0 +1 @@
+builder.Services.AddAzureBlobServices();

ndsdk/packages/file_storage_azure/appsettings.fragment.json.j2

@@ -0,0 +1,6 @@
+{
+  "AzureBlobStorage": {
+    "ConnectionString": "{{ settings.connection_string }}",
+    "Container": "{{ settings.container }}"
+  }
+}

ndsdk/packages/file_storage_azure/package.yaml

@@ -0,0 +1,9 @@
+key: file_storage_azure
+display_name: Azure File Storage Provider
+description: ND.FW.FileStorageProvider.Azure blob storage provider.
+nuget:
+  - { name: ND.FW.FileStorageProvider.Azure, version: 0.0.1 }
+defaults:
+  enabled: false
+  connection_string: "DefaultEndpointsProtocol=https;AccountName=ndwtchpidpdev;AccountKey=6Fi+iskcWsYeiemkLG6MSBhdeb5fDt/RKYnCYNK1i7BrcV+uSiYSIZU8F16Njwdwg7+3S1QZ2Vjl+ASt9xEMLw==;EndpointSuffix=core.windows.net"
+  container: dev

ndsdk/packages/observability/Program.fragment.cs.j2

@@ -0,0 +1,2 @@
+builder.Services.AddNDLogging(builder.Configuration);
+builder.Services.AddNDTracing(builder.Configuration);

ndsdk/packages/observability/appsettings.fragment.json.j2

@@ -0,0 +1,39 @@
+{
+  "Observability": {
+    "Logging": {
+      "Enabled": true,
+      "EnableExporter": true,
+      "ServiceName": "{{ settings.service_name | default(service_name) }}",
+      "MinimumLevel": "{{ settings.log_level }}",
+      "EnableConsole": {{ (settings.enable_console | default(true)) | tojson }},
+      "ExporterEndpoint": "{{ settings.exporter_endpoint }}/v1/logs",
+      "Protocol": "{{ settings.protocol }}"
+    },
+    "Tracing": {
+      "Enabled": true,
+      "EnableExporter": true,
+      "ServiceName": "{{ settings.service_name | default(service_name) }}",
+      "ExporterEndpoint": "{{ settings.exporter_endpoint }}/v1/traces",
+      "Protocol": "{{ settings.protocol }}",
+      "Instrumentation": {
+        "AspNet": true,
+        "HttpClient": true,
+        "SqlClient": true
+      }
+    },
+    "Metrics": {
+      "Enabled": true,
+      "EnableExporter": true,
+      "ServiceName": "{{ settings.service_name | default(service_name) }}",
+      "ExporterEndpoint": "{{ settings.exporter_endpoint }}/v1/metrics",
+      "Protocol": "{{ settings.protocol }}",
+      "Instrumentation": {
+        "Runtime": true,
+        "AspNet": true,
+        "HttpClient": true,
+        "Database": false
+      },
+      "CollectionIntervalSeconds": 10
+    }
+  }
+}

ndsdk/packages/observability/package.yaml

@@ -0,0 +1,16 @@
+key: observability
+display_name: Observability
+description: ND structured logging, tracing and metrics (OpenTelemetry exporters).
+nuget:
+  - { name: ND.FW.Observability, version: 0.0.7 }
+defaults:
+  enabled: true
+  logger_type: INDLoggerService
+  logger_namespace: ND.Observability.Framework.Core.Application.Handlers.Interface.Logging
+  service_name: IDP_WEB_API
+  log_level: Debug
+  enable_console: true
+  exporter_endpoint: http://nd-app-fw.ecarevantage.com:4318
+  protocol: http
+interactive:
+  - { key: log_level, prompt: "Log level", choices: [Trace, Debug, Information, Warning, Error], default: Debug }

ndsdk/registry.py

@@ -0,0 +1,192 @@
+"""Package registry.
+
+A *package* is an ND-provided capability (observability, db provider, storage,
+queue, …) that, when enabled in a service's config, contributes three things to
+the generated project:
+
+  1. NuGet ``<PackageReference>`` entries  -> the .csproj
+  2. A Program.cs registration fragment     -> dependency injection wiring
+  3. An appsettings.json fragment           -> configuration keys
+
+Each package is a self-contained folder under ``ndsdk/packages/<name>/`` owned
+by the ND-SDK maintainers (not the end user). Adding or changing a package is a
+folder edit — no generator code changes. That is the whole point: when the
+package changes, you edit the fragment here and every regenerated project
+picks it up.
+
+Folder layout::
+
+    packages/observability/
+        package.yaml                # metadata + nuget refs + defaults
+        Program.fragment.cs.j2      # rendered into Program.cs (optional)
+        appsettings.fragment.json.j2# rendered, merged into appsettings (optional)
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+PACKAGES_DIR = Path(__file__).parent / "packages"
+
+
+@dataclass
+class NugetRef:
+    name: str
+    version: str
+
+    @classmethod
+    def from_obj(cls, obj: Any) -> "NugetRef":
+        if isinstance(obj, str):
+            # allow "Newtonsoft.Json@13.0.3" or bare name
+            if "@" in obj:
+                name, version = obj.split("@", 1)
+                return cls(name.strip(), version.strip())
+            return cls(obj.strip(), "")
+        return cls(str(obj["name"]), str(obj.get("version", "")))
+
+
+@dataclass
+class Package:
+    """A loaded package definition."""
+
+    key: str
+    display_name: str
+    description: str
+    nuget: list[NugetRef] = field(default_factory=list)
+    defaults: dict[str, Any] = field(default_factory=dict)
+    interactive: list = field(default_factory=list)
+    program_fragment: str | None = None       # raw j2 template text (service registration)
+    app_fragment: str | None = None            # raw j2 template text (app pipeline / middleware)
+    appsettings_fragment: str | None = None    # raw j2 template text
+    _dir: Path | None = None
+
+    @classmethod
+    def load(cls, pkg_dir: Path) -> "Package":
+        meta = yaml.safe_load((pkg_dir / "package.yaml").read_text()) or {}
+        nuget = [NugetRef.from_obj(o) for o in meta.get("nuget", [])]
+
+        prog = pkg_dir / "Program.fragment.cs.j2"
+        app_frag = pkg_dir / "Program.app.fragment.cs.j2"
+        appsettings = pkg_dir / "appsettings.fragment.json.j2"
+
+        return cls(
+            key=meta.get("key", pkg_dir.name),
+            display_name=meta.get("display_name", pkg_dir.name),
+            description=meta.get("description", ""),
+            nuget=nuget,
+            defaults=meta.get("defaults", {}),
+            interactive=meta.get("interactive", []),
+            program_fragment=prog.read_text() if prog.exists() else None,
+            app_fragment=app_frag.read_text() if app_frag.exists() else None,
+            appsettings_fragment=appsettings.read_text() if appsettings.exists() else None,
+            _dir=pkg_dir,
+        )
+
+
+class PackageRegistry:
+    """Discovers and serves the packages shipped with the CLI."""
+
+    def __init__(self, packages_dir: Path = PACKAGES_DIR):
+        self.packages_dir = packages_dir
+        self._cache: dict[str, Package] = {}
+
+    def available(self) -> list[str]:
+        if not self.packages_dir.exists():
+            return []
+        return sorted(
+            p.name
+            for p in self.packages_dir.iterdir()
+            if p.is_dir() and (p / "package.yaml").exists()
+        )
+
+    def get(self, key: str) -> Package:
+        if key not in self._cache:
+            pkg_dir = self.packages_dir / key
+            if not (pkg_dir / "package.yaml").exists():
+                raise KeyError(
+                    f"Unknown package '{key}'. "
+                    f"Available: {', '.join(self.available()) or '(none)'}"
+                )
+            self._cache[key] = Package.load(pkg_dir)
+        return self._cache[key]
+
+    def resolve_enabled(self, pkg_config: dict[str, Any]) -> list[tuple[Package, dict]]:
+        """Given the merged ``packages`` block from config, return the
+        list of (Package, settings) pairs that are turned on.
+
+        ``settings`` is the package's own ``defaults`` deep-merged with whatever
+        the user supplied, so templates always see a complete settings dict.
+        """
+        resolved: list[tuple[Package, dict]] = []
+        for key, user_cfg in (pkg_config or {}).items():
+            user_cfg = user_cfg or {}
+            # a package is on unless explicitly disabled
+            if isinstance(user_cfg, dict) and user_cfg.get("enabled") is False:
+                continue
+            if user_cfg is False:
+                continue
+            try:
+                pkg = self.get(key)
+            except KeyError:
+                # unknown packages are surfaced by the validator; skip here
+                continue
+            settings = _deep_merge(pkg.defaults, user_cfg if isinstance(user_cfg, dict) else {})
+            resolved.append((pkg, settings))
+        return resolved
+
+
+def _deep_merge(base: dict, override: dict) -> dict:
+    out = dict(base)
+    for k, v in (override or {}).items():
+        if isinstance(v, dict) and isinstance(out.get(k), dict):
+            out[k] = _deep_merge(out[k], v)
+        else:
+            out[k] = v
+    return out
+
+
+def merge_appsettings(base: dict, fragment_json: str) -> dict:
+    """Merge a rendered appsettings fragment (JSON text) into the base dict."""
+    try:
+        frag = json.loads(fragment_json)
+    except json.JSONDecodeError as e:  # pragma: no cover - defensive
+        raise ValueError(f"appsettings fragment is not valid JSON: {e}\n{fragment_json}")
+    return _deep_merge(base, frag)
+
+
+def flatten_appsettings(data: dict, prefix: str = "", sep: str = "__") -> dict[str, str]:
+    """Flatten a nested appsettings dict into ASP.NET Core env-var keys.
+
+    Nested objects are joined with ``__`` (the .NET configuration provider's
+    hierarchy separator) and arrays are expanded with their numeric index, e.g.
+    ``ClientProvider:RetryPolicy:RetryableStatusCodes[0]`` becomes
+    ``ClientProvider__RetryPolicy__RetryableStatusCodes__0``. Values are
+    stringified so they can sit in ``launchSettings.json``'s
+    ``environmentVariables`` map.
+    """
+    out: dict[str, str] = {}
+    for key, value in (data or {}).items():
+        full = f"{prefix}{sep}{key}" if prefix else str(key)
+        if isinstance(value, dict):
+            out.update(flatten_appsettings(value, full, sep))
+        elif isinstance(value, list):
+            for idx, item in enumerate(value):
+                child = f"{full}{sep}{idx}"
+                if isinstance(item, (dict, list)):
+                    out.update(flatten_appsettings({str(idx): item}, full, sep))
+                else:
+                    out[child] = _stringify(item)
+        else:
+            out[full] = _stringify(value)
+    return out
+
+
+def _stringify(value) -> str:
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    return str(value)

ndsdk/templates/_common/BO.cs.j2

@@ -0,0 +1,10 @@
+// Generated by ND-SDK CLI. Business object.
+namespace {{ ns.bo }}
+{
+    public class {{ bo.name }}
+    {
+{% for f in bo.fields | default([]) %}
+        public {{ f.type | csharp_type }}{% if f.nullable | default(false) %}?{% endif %} {{ f.name | pascal_case }} { get; set; }
+{% endfor %}
+    }
+}

ndsdk/templates/_common/Controller.cs.j2

@@ -0,0 +1,131 @@
+// -----------------------------------------------------------------------------
+//  AUTO-GENERATED BY ND-SDK CLI — DO NOT EDIT.
+//  The controller layer is owned by the framework. Put your logic in the
+//  service layer ({{ service_name }}Service). Changes here are lost on regenerate.
+// -----------------------------------------------------------------------------
+using System.Text.Json;
+using Microsoft.AspNetCore.Mvc;
+{% if obs_enabled %}
+using {{ obs.logger_namespace }};
+{% endif %}
+using Swashbuckle.AspNetCore.Annotations;
+using {{ ns.service }};
+{% if dtos %}
+using {{ ns.dtos }};
+{% endif %}
+{% if models %}
+using {{ ns.models }};
+{% endif %}
+
+namespace {{ ns.controller }}
+{
+    [ApiController]
+    public class {{ service_name }}Controller : ControllerBase
+    {
+        private readonly IConfiguration _configuration;
+{% if not use_service_locator %}
+        private readonly I{{ service_name }}Service _service;
+{% endif %}
+{% if obs_enabled %}
+        private readonly {{ obs.logger_type }} _logger;
+        private readonly string ServiceName;
+{% endif %}
+
+        public {{ service_name }}Controller(
+            IConfiguration configuration{% if not use_service_locator %},
+            I{{ service_name }}Service service{% endif %}{% if obs_enabled %},
+            {{ obs.logger_type }} logger,
+            [FromKeyedServices("ServiceName")] string servicename{% endif %})
+        {
+            _configuration = configuration;
+{% if not use_service_locator %}
+            _service = service;
+{% endif %}
+{% if obs_enabled %}
+            _logger = logger;
+            ServiceName = servicename;
+{% endif %}
+        }
+
+        [HttpGet]
+        [Route("api/v1/health")]
+        [Produces("text/plain")]
+        [ProducesResponseType(typeof(string), StatusCodes.Status200OK)]
+        [SwaggerOperation(Summary = "Health check", OperationId = "HealthCheck")]
+        public string HealthCheck()
+        {
+            return "I'm Healthy";
+        }
+
+{% for ep in business_endpoints %}
+{% set method = ep.service_method | default(ep.name | pascal_case) %}
+{% set request_type = ep.request_dto | default(ep.request_model | default('')) %}
+{% set response_type = ep.response_dto | default(ep.response_model | default('')) %}
+{% set ret = response_type if response_type else "IActionResult" %}
+{% set call = "_service" if not use_service_locator else "ServiceManager.GetService<I" ~ service_name ~ "Service>()" %}
+        [Http{{ ep.http_method | default('GET') | capitalize }}]
+        [Route("{{ ep.route | default('api/v1/' ~ ep.name) }}")]
+{% if ep.consumes | default('') %}
+        [Consumes("{{ ep.consumes }}")]
+{% endif %}
+        [Produces("{{ ep.produces | default('application/json') }}")]
+{% if response_type %}
+        [ProducesResponseType(typeof({{ response_type }}), StatusCodes.Status200OK)]
+{% endif %}
+        [SwaggerOperation(Summary = "{{ ep.summary | default(ep.name) }}", OperationId = "{{ ep.name | pascal_case }}")]
+{% if ep.consumes | default('') == 'multipart/form-data' %}
+        public {{ ret }} {{ ep.name | pascal_case }}()
+        {
+            var formData = HttpContext.Request.Form;
+{% if request_type %}
+            {{ request_type }} input = JsonSerializer.Deserialize<{{ request_type }}>(formData["{{ ep.request_field | default('inputobj') }}"].ToString()) ?? new {{ request_type }}();
+{% endif %}
+{% elif request_type and ep.http_method | default('GET') | upper in ['POST', 'PUT', 'PATCH'] %}
+        public {{ ret }} {{ ep.name | pascal_case }}([FromBody] {{ request_type }} input)
+        {
+{% else %}
+        public {{ ret }} {{ ep.name | pascal_case }}()
+        {
+{% endif %}
+{% if obs_enabled %}
+            string correlationId = HttpContext.Request.Headers["X-Correlation-ID"].FirstOrDefault() ?? Guid.NewGuid().ToString();
+            _logger.LogInformation(ServiceName, "Request received", nameof({{ ep.name | pascal_case }}), correlationId);
+{% endif %}
+{% if response_type %}
+            {{ response_type }} response = new {{ response_type }}();
+{% endif %}
+            try
+            {
+{% if response_type %}
+                response = {{ call }}.{{ method }}({% if request_type %}input, {% endif %}_configuration);
+{% else %}
+                {{ call }}.{{ method }}({% if request_type %}input, {% endif %}_configuration);
+{% endif %}
+{% if obs_enabled %}
+                _logger.LogInformation(ServiceName, "Processing completed", nameof({{ ep.name | pascal_case }}), correlationId);
+{% endif %}
+            }
+            catch (Exception ex)
+            {
+{% if obs_enabled %}
+                _logger.LogError(ServiceName, "Unhandled exception", nameof({{ ep.name | pascal_case }}), correlationId, exception: ex, stackTrace: ex.StackTrace);
+{% else %}
+                throw;
+{% endif %}
+            }
+            finally
+            {
+                GC.Collect();
+                GC.WaitForPendingFinalizers();
+            }
+
+{% if response_type %}
+            return response;
+{% else %}
+            return Ok();
+{% endif %}
+        }
+
+{% endfor %}
+    }
+}

ndsdk/templates/_common/DbProviderBase.cs.j2

@@ -0,0 +1,26 @@
+// -----------------------------------------------------------------------------
+//  AUTO-GENERATED BY ND-SDK CLI — DO NOT EDIT.
+//  Abstract base for {{ provider.name }}. Method signatures are derived from the
+//  stored-procedure / externalization descriptors in config and are REFRESHED on
+//  every run. Implement the overrides in {{ provider.name }}.cs (yours, write-once).
+// -----------------------------------------------------------------------------
+using System.Collections.Generic;
+using Microsoft.Extensions.Configuration;
+{% if provider.has_relational and db_settings.types_namespace | default('') %}
+using {{ db_settings.types_namespace }};
+{% endif %}
+{% if entities %}
+using {{ ns.entities }};
+{% endif %}
+
+namespace {{ ns.provider }}
+{
+    public abstract class {{ provider.name }}Base
+    {
+{% for m in provider.methods %}
+        // {{ m.kind }} :: {% if m.relational %}sp={{ m.target }} -> {{ m.return_type_cs }}{% else %}{{ m.operation }} {{ m.target }} on {{ m.table | default('?') }}{% endif %}
+
+        public abstract {{ m.return_type_cs }} {{ m.name | pascal_case }}({% if m.entity is defined and m.entity %}{{ m.entity }} input, {% endif %}IConfiguration configuration);
+{% endfor %}
+    }
+}

ndsdk/templates/_common/Dockerfile.j2

@@ -0,0 +1,15 @@
+FROM mcr.microsoft.com/dotnet/aspnet:{{ dotnet | replace('net', '') }} AS base
+WORKDIR /app
+EXPOSE 80
+EXPOSE 443
+
+FROM mcr.microsoft.com/dotnet/sdk:{{ dotnet | replace('net', '') }} AS build
+WORKDIR /src
+COPY . .
+RUN dotnet restore "{{ service_name }}.csproj"
+RUN dotnet publish "{{ service_name }}.csproj" -c Release -o /app/publish /p:UseAppHost=false
+
+FROM base AS final
+WORKDIR /app
+COPY --from=build /app/publish .
+ENTRYPOINT ["dotnet", "{{ service_name }}.dll"]

ndsdk/templates/_common/Dto.cs.j2

@@ -0,0 +1,16 @@
+// Generated by ND-SDK CLI from config. API DTO contract.
+using System.Text.Json.Serialization;
+
+namespace {{ ns.dtos }}
+{
+    public class {{ dto.name }}
+    {
+{% for f in dto.fields | default([]) %}
+{% if f.json_name | default('') %}
+        [JsonPropertyName("{{ f.json_name }}")]
+{% endif %}
+        public {{ f.type | csharp_type }}{% if f.nullable | default(false) %}?{% endif %} {{ f.name | pascal_case }} { get; set; }{% if f.default is defined %} = {{ f.default }};{% endif %}
+
+{% endfor %}
+    }
+}

ndsdk/templates/_common/Entity.cs.j2

@@ -0,0 +1,16 @@
+// Generated by ND-SDK CLI from config. Provider input/output entity contract.
+using System.Text.Json.Serialization;
+
+namespace {{ ns.entities }}
+{
+    public class {{ entity.name }}
+    {
+{% for f in entity.fields | default([]) %}
+{% if f.json_name | default('') %}
+        [JsonPropertyName("{{ f.json_name }}")]
+{% endif %}
+        public {{ f.type | csharp_type }}{% if f.nullable | default(false) %}?{% endif %} {{ f.name | pascal_case }} { get; set; }{% if f.default is defined %} = {{ f.default }};{% endif %}
+
+{% endfor %}
+    }
+}