Skip to content

Templates & Libraries Overview

This document provides an overview of ConnectSoft's templates and libraries catalog. It is written for architects and engineers understanding what templates and libraries are available and how they're used by the Factory and in manual development.

ConnectSoft maintains a catalog of templates and libraries that form the building blocks for generated systems. Templates define standard structures and patterns, while libraries provide reusable functionality. Together, they ensure consistency, speed, reduced boilerplate, and encoded best practices across all ConnectSoft-generated systems.

Note

Templates are opinionated and follow ConnectSoft's architectural principles. They ensure consistency across all generated systems and make agent generation predictable. For layering and ConnectSoft.BaseTemplate, see Template Layering Guide. For ConnectSoft.MicroserviceTemplate and libraries, see Microservice Template and Libraries Catalog.

Why Templates & Libraries Matter

Templates and libraries are foundational to ConnectSoft's value proposition:

  • Consistency - Every generated system follows the same architectural patterns
  • Speed - Reduce boilerplate and repetitive code generation
  • Quality - Encode best practices (Clean Architecture, DDD, event-driven, observability)
  • Maintainability - Standardized structure makes codebases easier to understand and maintain
  • Agent Safety - Well-defined templates make agent generation predictable and safe

Without templates and libraries, the Factory would generate inconsistent, ad-hoc code. With them, every generation follows proven patterns.

Template Types

ConnectSoft maintains several types of templates:

Base Template

Purpose: Canonical microservice kernel (ConnectSoft.BaseTemplate) — shared layout, bootstrapping, and infrastructure without domain logic. Specialized template repos include it as the base-template git submodule.

Used By: All layered service templates; see Template Layering Guide and Template Architecture Overview.

Microservice Template (ConnectSoft.MicroserviceTemplate)

Purpose: Extended Factory template for full microservice scaffolds; builds on the base template and shared libraries.

Structure:

  • Domain Layer (entities, value objects, domain services, domain events)
  • Application Layer (use cases, workflows, DTOs)
  • Infrastructure Layer (repositories, external services, messaging)
  • API Layer (controllers, request/response models)
  • Tests Layer (unit, integration, acceptance tests)

Features: Clean Architecture, DDD, event-driven, multi-tenant, observability built-in

Used By: Engineering agents when generating new microservices

Library Template

Purpose: Reusable .NET libraries (shared domain, utilities, observability helpers) published as NuGet, with MSTest and Azure Pipelines.

Highlights: Multi-target net8 / net9 / net10; optional DI, logging, options, metrics, tracing via dotnet new flags; CLI connectsoft-library.

Used by: Engineering agents and developers scaffolding shared packages.

See: Library Template. Full CLI reference: ConnectSoft.Documentation → Library Template (parameters.md).

API Library Template (ConnectSoft.ApiLibraryTemplate)

Purpose: Reusable HTTP API client / service-agent libraries (auth layouts, resilience, optional metrics, WireMock tests), published as NuGet.

Highlights: Multi-target net8 / net9 / net10; CLI connectsoft-api-library; single AuthenticationType per scaffold; optional UseMetrics; Framework is a primary moniker (default net10.0).

Used by: Teams integrating third-party or internal HTTP APIs; Factory api-library-generator agent.

See: API Library Template. Full CLI reference: ConnectSoft.Documentation → API Library Template (parameters.md).

Documentation Site Template (MkDocs)

Purpose: Scaffold a standalone technical documentation site (MkDocs, Material theme, optional log4brains ADRs, sample Azure Pipelines) via dotnet new connectsoft-documentation.

Not to be confused with: the Platform Documentation Template used for content structure of platform pages inside this site.

See: Documentation Site Template (MkDocs). Canonical parameters: ConnectSoft.Documentation — documentation-template/parameters.md.

Infrastructure / DevOps Template

Purpose: Standard CI/CD pipelines and Infrastructure-as-Code

Structure:

  • Azure DevOps YAML pipelines (build, test, deploy)
  • Bicep templates for Azure resources
  • Kubernetes manifests
  • Deployment configurations

Features: Multi-environment support, observability integration, security best practices

Used By: DevOps agents when generating infrastructure

See: DevOps Templates for detailed specification

Frontend and CMS Templates

Purpose: Standard UI component structures and content management system integrations

Structure:

  • Frontend application scaffolding (Angular, React, Blazor)
  • CMS integration patterns
  • UI component libraries
  • State management patterns

Features: Modern frontend frameworks, headless CMS support, responsive design patterns

Used By: Frontend engineering agents when generating UI applications

See: Frontend and CMS Templates for detailed specification

Mobile App Templates

Purpose: Standard mobile application structures

Structure:

  • Cross-platform mobile app scaffolding
  • Native iOS/Android patterns
  • Mobile-specific UI components
  • Mobile API integration patterns

Features: Cross-platform support, native performance, mobile-specific best practices

Used By: Mobile engineering agents when generating mobile applications

See: Mobile App Templates for detailed specification

Observability Templates

Purpose: Standard observability and monitoring patterns

Structure:

  • OpenTelemetry integration
  • Logging patterns
  • Metrics collection
  • Tracing configuration

Features: Full observability stack, distributed tracing, metrics dashboards

Used By: Observability engineers and DevOps agents when setting up monitoring

See: Observability Templates for detailed specification

Security and Compliance Templates

Purpose: Standard security and compliance patterns

Structure:

  • Authentication/authorization patterns
  • Security best practices
  • Compliance templates (GDPR, SOC2, etc.)
  • Security scanning configurations

Features: Security-first design, compliance-ready patterns, security testing integration

Used By: Security engineers and architects when implementing security controls

See: Security and Compliance Templates for detailed specification

Library Families

ConnectSoft maintains several library families under the ConnectSoft.Extensions.* namespace:

Library Purpose Typical Consumers
ConnectSoft.Extensions.Logging Structured logging helpers, correlation IDs, OpenTelemetry integration All microservices
ConnectSoft.Extensions.Http HTTP client helpers, retry policies, circuit breakers Services calling external APIs
ConnectSoft.Extensions.OAuth2 OAuth2 client helpers, token management, OpenID Connect support Services authenticating users
ConnectSoft.Extensions.OpenTelemetry OpenTelemetry wiring, tracing configuration, metrics collection All microservices
ConnectSoft.Extensions.Audit Audit trail functionality, event capture Services needing audit logging
ConnectSoft.Extensions.Identity Identity and access helpers, tenant context Multi-tenant services
ConnectSoft.Extensions.Config Configuration management, feature flags Services needing external config
ConnectSoft.Extensions.Messaging Messaging abstractions, event publishing Event-driven services
ConnectSoft.Extensions.Persistence Persistence helpers, repository patterns Services with data access
ConnectSoft.Extensions.Testing Test utilities, BDD helpers, test data builders All test projects

All libraries follow ConnectSoft's architectural principles and are designed for multi-tenant SaaS applications.

How Templates and Libraries Are Used by the Factory

The Factory uses templates and libraries in a structured workflow:

  1. Architect Agents design bounded contexts and APIs
  2. Engineering Agents use the base template (via submodule) and ConnectSoft.MicroserviceTemplate to scaffold services
  3. Engineering Agents reference libraries via NuGet packages
  4. DevOps Agents use infrastructure templates for CI/CD and IaC
  5. All Agents store patterns in knowledge system for future reuse

The diagram below shows how templates and libraries flow through the Factory:

flowchart TD
    subgraph "Templates"
        MT[Microservice<br/>Template<br/>(extended)]
        LT[Library<br/>Template]
        IT[Infrastructure<br/>Template]
    end

    subgraph "Libraries"
        LIB1[ConnectSoft.Extensions.*<br/>NuGet Packages]
    end

    subgraph "Factory Agents"
        AA[Architect Agent]
        EA[Engineering Agent]
        DA[DevOps Agent]
    end

    subgraph "Knowledge System"
        KS[Pattern Storage<br/>Vector DB]
    end

    AA -->|Designs| EA
    EA -->|Uses| MT
    EA -->|Uses| LT
    EA -->|References| LIB1
    DA -->|Uses| IT

    EA -->|Stores Patterns| KS
    KS -->|Reuses| EA

    EA -->|Generates| CODE[Generated Code<br/>Customer Repos]

    style MT fill:#2563EB,color:#fff
    style LIB1 fill:#4F46E5,color:#fff
    style CODE fill:#10B981,color:#fff
Hold "Alt" / "Option" to enable pan & zoom

Tip

Templates ensure consistency, while libraries provide reusable functionality. Together, they enable the Factory to generate production-ready code quickly and reliably. Every generation uses the same templates and libraries, ensuring architectural consistency across all customer projects.

How Engineers Should Use Them Manually

If you're not using the Factory, you can still benefit from templates and libraries:

Using Templates Manually

  • Start from the base or microservice template - Use ConnectSoft.BaseTemplate (base-template) and/or ConnectSoft.MicroserviceTemplate as appropriate; see Template Layering Guide
  • Follow the structure - Use the same ConnectSoft.*.*Model / host / tests project layout as ConnectSoft.BaseTemplate (see Template Layering Guide)
  • Customize as needed - Adapt templates to your specific needs while maintaining structure
  • Reference examples - Look at Factory-generated services as examples

Using Libraries Manually

  • Install NuGet packages - Add ConnectSoft.Extensions.* packages to your projects
  • Follow patterns - Use libraries as intended (see library documentation)
  • Extend if needed - Create your own extensions following ConnectSoft patterns
  • Stay updated - Keep libraries updated for bug fixes and new features

Benefits of Manual Use

  • Consistency - Same patterns as Factory-generated code
  • Best practices - Libraries encode proven patterns
  • Community - Share patterns with Factory users
  • Migration path - Easy to migrate to Factory later

Note

Templates and libraries are designed to work together. Using templates without libraries, or libraries without templates, reduces their effectiveness. For best results, use both following ConnectSoft's architectural principles.

Template Catalog

ConnectSoft maintains templates for all major system components:

Template Architecture

ConnectSoft templates follow a three-layer architecture that eliminates duplication while maintaining flexibility: