ndsdk-cli 1.0.0__py3-none-any.whl

ndsdk/main.py

@@ -0,0 +1,536 @@
+"""ND-SDK CLI — entrypoint.
+
+Commands mirror the Python reference (init / generate / validate / preview) plus
+two introspection commands (packages / architectures) that expose what the CLI
+maintainers have made available.
+"""
+
+from __future__ import annotations
+from importlib.metadata import version
+
+
+from pathlib import Path
+
+import click
+import yaml
+
+from . import __version__
+from .config_normalizer import normalize_config
+from .generators import available_architectures, available_variants, get_generator
+from .generators.engine import GenerationFilter, available_layers
+from .registry import PackageRegistry
+from .validators import ConfigValidator
+
+
+@click.group()
+@click.version_option()
+def cli():
+    """ND-SDK — metadata-driven C# scaffolding generator."""
+
+
+# --------------------------------------------------------------------------- #
+def _ask_loop(label, build, *, first_default=True):
+    """Repeatedly run build() while the user wants to add more of `label`."""
+    items = []
+    while click.confirm(f"  Add {'an' if label[0] in 'aeiou' else 'a'} {label}?",
+                        default=first_default if not items else False):
+        item = build()
+        if item is not None:
+            items.append(item)
+    return items
+
+
+def _prompt_optional(label, default=""):
+    val = click.prompt(label, default=default, show_default=bool(default))
+    return val or None
+
+
+def _build_field():
+    name = click.prompt("      Field name")
+    ftype = click.prompt("      Type (string, int, bool, list<Foo>, dict<string,int>, Foo[])",
+                         default="string")
+    nullable = click.confirm("      Nullable?", default=False)
+    json_name = _prompt_optional("      JSON property name (blank = none)")
+    f = {"name": name, "type": ftype}
+    if nullable:
+        f["nullable"] = True
+    if json_name:
+        f["json_name"] = json_name
+    return f
+
+
+def _build_model():
+    name = click.prompt("    Model name")
+    fields = []
+    while click.confirm(f"    Add a field to {name}?", default=True):
+        fields.append(_build_field())
+    return {"name": name, "fields": fields}
+
+
+def _build_provider(entity_names):
+    name = click.prompt("    Provider name")
+    kind = click.prompt(
+        "    Provider kind",
+        type=click.Choice(["custom", "database", "storage", "queue", "http_api", "cache", "ai_model"], case_sensitive=False),
+        default="custom",
+    ).lower()
+    integration = _prompt_optional("    Integration name this provider uses (blank = none)")
+
+    prov = {"name": name, "kind": kind}
+    if integration:
+        prov["integration"] = integration
+
+    if not click.confirm(f"    Add methods to {name}?", default=(kind == "database")):
+        base = click.prompt("    Base class", default="ProviderBase")
+        prov["base"] = base
+        return prov
+
+    prov["methods"] = []
+    while click.confirm(f"    Add a method to {name}?", default=True):
+        if kind == "database":
+            prov["methods"].append(_build_db_method(entity_names))
+        else:
+            prov["methods"].append(_build_generic_method(entity_names, kind))
+    return prov
+
+
+def _build_generic_method(entity_names, provider_kind):
+    mname = click.prompt("      Method name")
+    operation = click.prompt("      Operation", default="execute")
+    returns = click.prompt("      Return type", default="object")
+    hint = f" (defined: {', '.join(entity_names)})" if entity_names else ""
+    entity = _prompt_optional(f"      Input entity{hint} (blank = none)")
+    m = {"name": mname, "operation": operation, "returns": returns, "settings": {}}
+    if entity:
+        m["input_entity"] = entity
+    return m
+
+
+def _build_db_method(entity_names):
+    mname = click.prompt("      Method name")
+    operation = click.prompt(
+        "      Operation",
+        type=click.Choice(["query", "stored_procedure"], case_sensitive=False),
+        default="query",
+    ).lower()
+    returns = click.prompt("      Return type", default="object")
+    hint = f" (defined: {', '.join(entity_names)})" if entity_names else ""
+    entity = _prompt_optional(f"      Input entity{hint} (blank = none)")
+    m = {"name": mname, "operation": operation, "returns": returns, "settings": {}}
+    if entity:
+        m["input_entity"] = entity
+
+    if operation == "stored_procedure":
+        m["settings"]["stored_procedure"] = click.prompt("      Stored procedure name")
+        params = []
+        while click.confirm("      Add a parameter?", default=True):
+            pname = click.prompt("        Parameter name")
+            direction = click.prompt("        Direction",
+                                     type=click.Choice(["in", "out", "cursor"]), default="in")
+            param = {"name": pname, "direction": direction}
+            if direction == "in" and entity:
+                ef = _prompt_optional("        Bind from entity field (blank = none)")
+                if ef:
+                    param["entity_field"] = ef
+            if direction == "out":
+                ptype = _prompt_optional("        DB type (e.g. Int, VarChar; blank = adapter default)")
+                if ptype:
+                    param["type"] = ptype
+                if ptype and ptype.lower() in {"varchar", "nvarchar", "varbinary", "char"}:
+                    size = _prompt_optional("        Size (blank = none)")
+                    if size and size.isdigit():
+                        param["size"] = int(size)
+            if direction == "cursor":
+                param["cursor_name"] = click.prompt("        Cursor name", default=f"{pname}_cursor")
+            params.append(param)
+        m["settings"]["parameters"] = params
+    else:
+        m["settings"]["target"] = click.prompt("      Target", default="GetResults")
+        m["settings"]["table"] = click.prompt("      Table name")
+        inputs = []
+        while click.confirm("      Add an input parameter?", default=True):
+            key = click.prompt("        Key (e.g. PrimaryValue)")
+            if entity and click.confirm("        Bind from entity field?", default=True):
+                inputs.append({"key": key, "entity_field": click.prompt("        Entity field")})
+            else:
+                inputs.append({"key": key, "value": click.prompt("        Literal value", default="")})
+        m["settings"]["inputs"] = inputs
+    return m
+
+
+def _build_entity():
+    name = click.prompt("    Entity name")
+    fields = []
+    while click.confirm(f"    Add a field to {name}?", default=True):
+        fields.append(_build_field())
+    return {"name": name, "fields": fields}
+
+
+def _build_bo():
+    name = click.prompt("    BO name")
+    fields = []
+    while click.confirm(f"    Add a field to {name}?", default=False):
+        fields.append(_build_field())
+    bo = {"name": name}
+    if fields:
+        bo["fields"] = fields
+    return bo
+
+
+def _build_endpoint(model_names):
+    name = click.prompt("    Endpoint name")
+    method = click.prompt(
+        "    HTTP method",
+        type=click.Choice(["GET", "POST", "PUT", "DELETE", "PATCH"], case_sensitive=False),
+        default="POST",
+    ).upper()
+    route = click.prompt("    Route", default=f"api/v1/{name}")
+    summary = _prompt_optional("    Summary", default=f"{name} endpoint")
+    description = _prompt_optional("    Description (blank = none)")
+
+    ep = {"name": name, "http_method": method, "route": route}
+    if summary:
+        ep["summary"] = summary
+    if description:
+        ep["description"] = description
+
+    if method in ("POST", "PUT", "PATCH"):
+        consumes = click.prompt(
+            "    Consumes",
+            type=click.Choice(["application/json", "multipart/form-data", "none"]),
+            default="application/json",
+        )
+        if consumes != "none":
+            ep["consumes"] = consumes
+        if consumes == "multipart/form-data":
+            ep["request_field"] = click.prompt("    Form field holding the JSON payload",
+                                               default="inputobj")
+
+    hint = f" (defined: {', '.join(model_names)})" if model_names else ""
+    req = _prompt_optional(f"    Request model{hint}")
+    if req:
+        ep["request_model"] = req
+    resp = _prompt_optional(f"    Response model{hint}")
+    if resp:
+        ep["response_model"] = resp
+    ep["service_method"] = click.prompt("    Service method name",
+                                        default="".join(w.capitalize() for w in
+                                                        name.replace("-", " ").replace("_", " ").split()))
+    return ep
+
+
+def _prompt_packages(registry, *, indent="  "):
+    """Enable packages and collect their user-facing settings."""
+    enabled = {}
+    for key in registry.available():
+        pkg = registry.get(key)
+        if click.confirm(f"{indent}Enable {pkg.display_name}?",
+                         default=pkg.defaults.get("enabled", False)):
+            settings = {"enabled": True}
+            for spec in pkg.interactive:
+                if spec.get("choices"):
+                    val = click.prompt(
+                        f"{indent}  {spec.get('prompt', spec['key'])}",
+                        type=click.Choice(spec["choices"]),
+                        default=spec.get("default"),
+                    )
+                else:
+                    val = click.prompt(f"{indent}  {spec.get('prompt', spec['key'])}",
+                                       default=spec.get("default", ""))
+                settings[spec["key"]] = val
+            enabled[key] = settings
+    return enabled
+
+
+def _prompt_nuget_list(label):
+    """Collect a list of {name, version} refs (version optional -> latest)."""
+    refs = []
+    while click.confirm(f"  Add a{label}?", default=False):
+        name = click.prompt("    Package name")
+        version = _prompt_optional("    Version (blank = latest)")
+        ref = {"name": name}
+        if version:
+            ref["version"] = version
+        refs.append(ref)
+    return refs
+
+
+@cli.command()
+@click.option("--output", "-o", default="nd-config.yaml", help="Config file to write.")
+def init(output):
+    """Create a config file interactively (covers the full schema)."""
+    config_path = Path(output)
+    click.secho("ND-SDK Project Generator\n", fg="cyan", bold=True)
+
+    # ---- project ----
+    click.secho("Project", fg="yellow", bold=True)
+    name = click.prompt("Solution name", default="ND.SampleSuite")
+    namespace_root = click.prompt("Root namespace (blank = service name)", default="ND")
+
+    variants = available_variants()
+    types = sorted({t for t, _ in variants})
+    ptype = click.prompt("Project type", type=click.Choice(types), default="microservice")
+    styles = sorted({s for t, s in variants if t == ptype})
+    architecture = click.prompt("Architecture style", type=click.Choice(styles), default=styles[0])
+    dotnet = click.prompt("Target framework", default="net8.0")
+    version_strategy = click.prompt(
+        "Default NuGet version when unpinned",
+        type=click.Choice(["floating", "omit"]),
+        default="floating",
+    )
+
+    project = {
+        "name": name,
+        "namespace_root": namespace_root,
+        "type": ptype,
+        "architecture": architecture,
+        "dotnet_version": dotnet,
+        "nuget_version_strategy": version_strategy,
+    }
+
+    # ---- defaults: packages + extra nuget ----
+    registry = PackageRegistry()
+    click.secho("\nPackages (solution defaults)", fg="yellow", bold=True)
+    default_packages = _prompt_packages(registry)
+
+    click.secho("\nExtra solution-wide NuGet packages", fg="yellow", bold=True)
+    default_nuget = _prompt_nuget_list(" package")
+
+    # ---- package version pins ----
+    click.secho("\nPin specific package versions? (otherwise the strategy above applies)",
+                fg="yellow", bold=True)
+    package_versions = {}
+    while click.confirm("  Pin a package version?", default=False):
+        pname = click.prompt("    NuGet package name (e.g. ND.Observability.Framework)")
+        pver = click.prompt("    Version")
+        package_versions[pname] = pver
+
+    # ---- services ----
+    services = []
+    add_more = True
+    while add_more:
+        click.secho(f"\nService #{len(services) + 1}", fg="yellow", bold=True)
+        svc_name = click.prompt("  Service name", default="SampleService")
+        port = click.prompt("  Local port", default=5000, type=int)
+
+        svc = {"name": svc_name, "port": port}
+
+        if click.confirm("  Override packages for this service?", default=False):
+            svc["packages"] = _prompt_packages(registry, indent="    ")
+
+        # ---- integrations (all provider types use the same config shape) ----
+        integrations = []
+        if click.confirm("  Add a database integration?", default=False):
+            db_type = click.prompt("    Database type",
+                                   type=click.Choice(["non_relational", "relational"]),
+                                   default="non_relational")
+            store = click.prompt("    Store / engine (e.g. cassandra, dynamodb, postgres, sqlserver)",
+                                 default="cassandra" if db_type == "non_relational" else "sqlserver")
+            integration = {
+                "name": click.prompt("    Integration name", default="database"),
+                "kind": "database",
+                "provider": store,
+                "settings": {"database_type": db_type},
+            }
+            conn_name = click.prompt("    Connection string name", default="DefaultConnection" if db_type == "relational" else "CassandraConnection")
+            if conn_name:
+                integration["settings"]["connection_string_name"] = conn_name
+            integrations.append(integration)
+
+        click.secho("  Models / DTOs", fg="yellow")
+        models = _ask_loop("model", _build_model, first_default=True)
+        model_names = [m["name"] for m in models]
+
+        click.secho("  Entities (input objects for stored-procedure / provider calls)", fg="yellow")
+        entities = _ask_loop("entity", _build_entity, first_default=False)
+        entity_names = [e["name"] for e in entities]
+
+        click.secho("  Endpoints", fg="yellow")
+        endpoints = _ask_loop("endpoint", lambda: _build_endpoint(model_names), first_default=True)
+
+        click.secho("  Business objects (BO)", fg="yellow")
+        bos = _ask_loop("BO", _build_bo, first_default=False)
+
+        click.secho("  Providers", fg="yellow")
+        providers = _ask_loop("provider", lambda: _build_provider(entity_names), first_default=False)
+
+        svc["endpoints"] = endpoints
+        svc["models"] = models
+        if integrations:
+            svc["integrations"] = integrations
+        if entities:
+            svc["entities"] = entities
+        if bos:
+            svc["bos"] = bos
+        if providers:
+            svc["providers"] = providers
+        services.append(svc)
+
+        add_more = click.confirm("\nAdd another service?", default=False)
+
+    # ---- assemble ----
+    config = {"project": project}
+    defaults = {}
+    if default_packages:
+        defaults["packages"] = default_packages
+    if default_nuget:
+        defaults["nuget"] = default_nuget
+    if defaults:
+        config["defaults"] = defaults
+    if package_versions:
+        config["package_versions"] = package_versions
+    config["services"] = services
+
+    if config_path.exists() and not click.confirm(f"{output} exists. Overwrite?"):
+        return
+    config_path.write_text(yaml.dump(config, sort_keys=False, indent=2))
+    click.secho(f"\n✓ Created {output}", fg="green", bold=True)
+
+    ok, errors = ConfigValidator().validate(config)
+    if ok:
+        click.echo(f"  Validated OK. Next: ndsdk generate -c {output}")
+    else:
+        click.secho("  Note: config has validation issues:", fg="yellow")
+        for e in errors:
+            click.secho(f"    • {e}", fg="yellow")
+
+
+# --------------------------------------------------------------------------- #
+@cli.command()
+@click.option("--config", "-c", type=click.Path(exists=True), required=True)
+@click.option("--output", "-o", type=click.Path(), default=".")
+@click.option("--force", "-f", is_flag=True, help="Overwrite write-once (user-owned) files too.")
+@click.option("--service", "-s", "services", multiple=True,
+              help="Only (re)generate these services. Repeatable.")
+@click.option("--layer", "-l", "layers", multiple=True,
+              help="Only (re)generate these layers (e.g. model, provider, service). Repeatable.")
+def generate(config, output, force, services, layers):
+    """Generate a C# solution from a config file.
+
+    Selective regeneration: restrict to one or more services and/or layers, e.g.
+    `ndsdk generate -c cfg.yaml -s OrderService -l model` rebuilds only that
+    service's models. Add --force to re-scaffold write-once files (service impl,
+    provider scaffolds). A filtered run never rewrites the .sln or config copy.
+    """
+    config_data = yaml.safe_load(Path(config).read_text())
+
+    ok, errors = ConfigValidator().validate(config_data)
+    if not ok:
+        click.secho("Configuration invalid:", fg="red", bold=True)
+        for e in errors:
+            click.secho(f"  • {e}", fg="red")
+        raise SystemExit(1)
+
+    known_layers = set(available_layers())
+    bad = [l for l in layers if l not in known_layers]
+    if bad:
+        click.secho(
+            f"Unknown layer(s): {', '.join(bad)}. Available: {', '.join(sorted(known_layers))}",
+            fg="red", bold=True,
+        )
+        raise SystemExit(1)
+
+    flt = GenerationFilter(services=set(services), layers=set(layers), force=force)
+
+    generator = get_generator(config_data, output)
+    if services:
+        known_svcs = {s["name"] for s in config_data.get("services", [])}
+        missing = [s for s in services if s not in known_svcs]
+        if missing:
+            click.secho(f"Unknown service(s): {', '.join(missing)}", fg="red", bold=True)
+            raise SystemExit(1)
+
+    if not flt.active and generator.solution_dir.exists() and not force:
+        click.confirm(
+            f"'{generator.solution_name}' exists. Overwrite?", abort=True
+        )
+
+    if flt.active:
+        scope = []
+        if services:
+            scope.append("services=" + ",".join(services))
+        if layers:
+            scope.append("layers=" + ",".join(layers))
+        click.echo(f"Selective regenerate ({'; '.join(scope)})"
+                   f"{' [--force]' if force else ''}...")
+    else:
+        click.echo(f"Generating {generator.ptype}/{generator.style} "
+                   f"solution '{generator.solution_name}'...")
+
+    files = generator.generate(flt)
+    click.secho(f"\n✓ Wrote {len(files)} files to {generator.solution_dir}", fg="green", bold=True)
+
+
+# --------------------------------------------------------------------------- #
+@cli.command()
+@click.argument("config", type=click.Path(exists=True))
+def validate(config):
+    """Validate a config file."""
+    config_data = yaml.safe_load(Path(config).read_text())
+    ok, errors = ConfigValidator().validate(config_data)
+    if ok:
+        click.secho("✓ Configuration is valid", fg="green", bold=True)
+    else:
+        click.secho("✗ Configuration has errors:", fg="red", bold=True)
+        for e in errors:
+            click.secho(f"  • {e}", fg="red")
+        raise SystemExit(1)
+
+
+# --------------------------------------------------------------------------- #
+@cli.command()
+@click.argument("config", type=click.Path(exists=True))
+def preview(config):
+    """Show what would be generated without writing files."""
+    config_data = normalize_config(yaml.safe_load(Path(config).read_text()))
+    project = config_data.get("project", {})
+    click.secho(f"Solution: {project.get('name')}", fg="cyan", bold=True)
+    click.echo(f"Architecture: {project.get('type', 'microservice')}/{project.get('architecture', 'layered')}")
+    click.echo(f"Framework: {project.get('dotnet_version', 'net8.0')}")
+    for svc in config_data.get("services", []):
+        click.secho(f"\n  {svc['name']}/", fg="yellow", bold=True)
+        click.echo(f"    Controllers/{svc['name']}Controller.cs  (locked)")
+        click.echo(f"    Service/I{svc['name']}Service.cs        (generated)")
+        click.echo(f"    Service/{svc['name']}Service.cs         (stub)")
+        for ep in svc.get("endpoints", []):
+            click.echo(f"      {ep.get('http_method', 'GET'):6} /{ep.get('route', ep['name'])}")
+        for d in svc.get("dtos", []):
+            click.echo(f"    Dtos/{d['name']}.cs")
+        for m in svc.get("models", []):
+            click.echo(f"    Models/{m['name']}.cs")
+
+
+# --------------------------------------------------------------------------- #
+@cli.command()
+def packages():
+    """List packages the CLI can wire in."""
+    registry = PackageRegistry()
+    click.secho("Available packages:\n", fg="cyan", bold=True)
+    for key in registry.available():
+        pkg = registry.get(key)
+        click.secho(f"  {pkg.key}", fg="yellow", bold=True)
+        click.echo(f"    {pkg.description}")
+        if pkg.nuget:
+            refs = ", ".join(f"{r.name} {r.version}".strip() for r in pkg.nuget)
+            click.echo(f"    NuGet: {refs}")
+
+
+@cli.command()
+def architectures():
+    """List supported architectures (type / style)."""
+    click.secho("Available architectures (type/style):", fg="cyan", bold=True)
+    for t_, s_ in available_variants():
+        click.echo(f"  • {t_}/{s_}")
+
+
+@cli.command()
+def layers():
+    """List layers that can be selectively (re)generated via `generate --layer`."""
+    click.secho("Selectively regenerable layers:", fg="cyan", bold=True)
+    for layer in available_layers():
+        click.echo(f"  • {layer}")
+    click.echo("\n  e.g. ndsdk generate -c nd-config.yaml -s OrderService -l model -l provider")
+
+
+if __name__ == "__main__":
+    cli()

ndsdk/naming.py

@@ -0,0 +1,112 @@
+"""Naming helpers shared by templates and generators.
+
+C# leans on PascalCase for types/namespaces and camelCase for locals/params,
+so the Jinja filters here mirror that. Kept dependency-free on purpose.
+"""
+
+import re
+
+
+def _words(text: str) -> list[str]:
+    """Split an arbitrary identifier into lowercase words."""
+    if not text:
+        return []
+    # insert breaks: aB -> a B, ABc -> A Bc
+    text = re.sub(r"([a-z0-9])([A-Z])", r"\1 \2", text)
+    text = re.sub(r"([A-Z]+)([A-Z][a-z])", r"\1 \2", text)
+    text = text.replace("-", " ").replace("_", " ").replace(".", " ")
+    return [w for w in text.split() if w]
+
+
+def pascal_case(text: str) -> str:
+    """`perform-textract` -> `PerformTextract`."""
+    return "".join(w[:1].upper() + w[1:] for w in _words(text))
+
+
+def camel_case(text: str) -> str:
+    """`PerformTextract` -> `performTextract`."""
+    p = pascal_case(text)
+    return p[:1].lower() + p[1:] if p else p
+
+
+def snake_case(text: str) -> str:
+    return "_".join(w.lower() for w in _words(text))
+
+
+def kebab_case(text: str) -> str:
+    return "-".join(w.lower() for w in _words(text))
+
+
+def namespace(*parts: str) -> str:
+    """Join namespace segments, each PascalCased, skipping empties.
+
+    `namespace("ND", "perform-textract")` -> `ND.PerformTextract`
+    """
+    segs = []
+    for part in parts:
+        if not part:
+            continue
+        # a part may itself already be dotted (e.g. "ND.Observability")
+        for seg in str(part).split("."):
+            if seg:
+                segs.append(pascal_case(seg))
+    return ".".join(segs)
+
+
+# Map loose YAML type names onto C# types so the same config can describe
+# a model field once and be rendered correctly.
+_CSHARP_TYPE_MAP = {
+    "string": "string",
+    "str": "string",
+    "int": "int",
+    "integer": "int",
+    "long": "long",
+    "float": "float",
+    "double": "double",
+    "decimal": "decimal",
+    "bool": "bool",
+    "boolean": "bool",
+    "datetime": "DateTime",
+    "date": "DateTime",
+    "guid": "Guid",
+    "object": "object",
+    "dynamic": "dynamic",
+}
+
+
+def csharp_type(type_name: str) -> str:
+    """Resolve a config type string into a C# type.
+
+    Handles `list<T>` / `List<T>` and `T[]`, leaving unknown (custom) types
+    such as `ADCItem` untouched so they can reference generated models.
+    """
+    if not type_name:
+        return "object"
+    raw = str(type_name).strip()
+
+    # array suffix: Foo[]
+    if raw.endswith("[]"):
+        return f"{csharp_type(raw[:-2])}[]"
+
+    # generic list/collection: list<Foo>, List<Foo>, ienumerable<Foo>
+    m = re.match(r"^(list|ilist|ienumerable|collection)<(.+)>$", raw, re.IGNORECASE)
+    if m:
+        inner = csharp_type(m.group(2))
+        return f"List<{inner}>"
+
+    # dictionary<K,V>
+    m = re.match(r"^(dict|dictionary)<(.+),(.+)>$", raw, re.IGNORECASE)
+    if m:
+        return f"Dictionary<{csharp_type(m.group(2))}, {csharp_type(m.group(3))}>"
+
+    return _CSHARP_TYPE_MAP.get(raw.lower(), raw)
+
+
+def register_filters(env) -> None:
+    """Attach all naming helpers as Jinja filters on an Environment."""
+    env.filters["pascal_case"] = pascal_case
+    env.filters["camel_case"] = camel_case
+    env.filters["snake_case"] = snake_case
+    env.filters["kebab_case"] = kebab_case
+    env.filters["csharp_type"] = csharp_type
+    env.globals["ns"] = namespace

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

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

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

@@ -0,0 +1,14 @@
+{
+  "ClientProvider": {
+    "TimeoutInSeconds": {{ settings.timeout_in_seconds }},
+    "RetryPolicy": {
+      "MaxRetryAttempts": {{ settings.max_retry_attempts }},
+      "RetryDelayInSeconds": {{ settings.retry_delay_in_seconds }},
+      "RetryableStatusCodes": {{ settings.retryable_status_codes | tojson }}
+    },
+    "CircuitBreaker": {
+      "FailureThreshold": {{ settings.failure_threshold }},
+      "DurationOfBreakInSeconds": {{ settings.duration_of_break_in_seconds }}
+    }
+  }
+}

ndsdk/packages/client_provider/package.yaml

@@ -0,0 +1,13 @@
+key: client_provider
+display_name: Client Provider
+description: ND.FW.ClientProvider resilient HTTP client (timeout, retry, circuit breaker).
+nuget:
+  - { name: ND.FW.ClientProvider, version: 0.0.3 }
+defaults:
+  enabled: true
+  timeout_in_seconds: 30
+  max_retry_attempts: 3
+  retry_delay_in_seconds: 2
+  retryable_status_codes: [408, 429, 500, 502, 503, 504]
+  failure_threshold: 5
+  duration_of_break_in_seconds: 30

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

@@ -0,0 +1,3 @@
+builder.Services.AddDBAccessLayer(builder.Configuration);
+builder.Services.AddNoSqlProvider(builder.Configuration);
+builder.Services.AddDbProviderServices();