Implementation Completion Prompts

After FlexBase Studio generates skeleton code, use these tasks to complete API business logic and generate UI pages/components — driven by your extraction JSON and Markdown artifacts.

Works for all entry points: Legacy Migration, BRD Extraction, and New Application Design.

How to Use

Tell your AI agent which feature or module to implement. It will load the implementation completion guide and relevant conventions to produce production-ready code.

Example prompts you can give your AI agent:

Complete the API business logic for the Schedule module using the extraction JSON

Generate Blazor CRUD pages for the Person entity from the feature JSON

Add [Table] and [Column] annotations for legacy database column names

Implement all validations for CreateBooking from the extraction data

Complete the Angular service and list component for Orders

Walk me through implementing the entire Customer module end-to-end

Complete the implementation — move stored procedure logic to C# handlers

Complete the implementation — use stored procedures for complex queries

Generate database scripts for the stored procedures

Implement the CreateProduct handler using Document Store for CosmosDB

Add Redis caching to the GetProducts query with cache-aside pattern

Send a confirmation email after order creation using Email Provider

Implement AI-powered product classification using Azure OpenAI in the CreateProduct handler

Add vector search to the SearchArticles query using PgVector for semantic results

Store uploaded documents in Azure Blob Storage from the CreateDocument handler

---

Task Catalog

Task 1: Complete Domain Model from Extraction JSON

Goal: Fill in generated domain model partial classes with attributes, relationships, and legacy name annotations User provides: Module name, extraction JSON file path (or entity name)

Task 1b: Configure Database Indexes

Goal: Add index configuration from extraction JSON index definitions User provides: Extraction JSON with index arrays per domain entity

Task 2: Complete Domain Factory Methods

Goal: Implement Create and Update factory methods using extraction feature details User provides: Entity name, extraction JSON feature for CREATE/UPDATE

Task 2b: Complete Handler with Stored Procedure Logic

Goal: Implement handler using stored procedure documentation as the specification User provides: Feature name with SP flag in extraction JSON + SP documentation file

Options:

• Move to Code (DEFAULT): SP logic translated to C# handler/query code

• Call Stored Procedures: Keep SPs in the database and call them from handlers — generates database migration scripts

Task 3: Complete Handler Business Logic

Goal: Implement handler Execute method with orchestration from extraction features User provides: Feature name (e.g., CreateSchedule), extraction JSON

Task 4: Complete Query Implementations

Goal: Implement query filters, includes, and projections from extraction features User provides: Module or entity name, extraction JSON with GETPAGEDLIST/GETLIST features

Task 5: Complete Validation Plugins

Goal: Implement pre-bus validation logic from extraction validations User provides: Feature name, extraction JSON validations section

Task 6: Complete DTOs and Mappers

Goal: Fill in generated DTOs with properties and validation annotations from extraction, then create mapper expressions User provides: Entity name, extraction JSON domain services

Task 7: Complete Workflow States

Goal: Implement workflow state pattern from extraction workflow/status information User provides: Entity name, extraction JSON or Markdown with workflow/status information

Task 8: Complete Event Subscribers

Goal: Implement event reactions from extraction events and subscribers User provides: Feature name, extraction JSON events/subscribers section

Task 9: Add Legacy Name Retention

Goal: Add [Table] and [Column] annotations for legacy database compatibility User provides: Entity name or "all entities", extraction JSON with originalName fields

Task 10: Generate Blazor UI from Extraction — Complete Module

Goal: Create the full Blazor FluentUI v4.x UI stack for a module — REST client, DTOs, dialog, list page, navigation — from extraction JSON or API project discovery User provides: Module name (e.g., "Products"), extraction JSON files or FlexBase API project User says: "Generate Blazor pages for the Products module"

What gets generated:

1. UI DTOs (list + detail with validation annotations)

2. REST client service with CRUD methods

3. DI registration

4. Edit dialog (view/edit/create modes)

5. List page (DataGrid with search, filter, CRUD)

6. Sidebar/navigation entry

Task 11: Generate Angular UI from Extraction

Goal: Create Angular components and services from extraction JSON User provides: Module or entity name, extraction JSON, target Angular project

Task 12: Generate React UI from Extraction

Goal: Create React components and hooks from extraction JSON User provides: Module or entity name, extraction JSON, target React project

Task 13: Complete Entire Module (API + UI)

Goal: End-to-end implementation of a module — all domain models, handlers, queries, validations, DTOs, and UI User provides: Module name, all extraction JSON files, target UI framework

Implementation order:

1. Domain models → DTOs & mappers → Queries → Validations → Handlers → Subscribers → UI → Build & verify

---

DataStore, AI & Email Provider Integration

These prompts add non-relational data store, AI, or email operations into FlexBase handlers, queries, subscribers, and validation plugins. Each provider follows the same pattern: inject the bridge interface, call the provider-specific operations, and let the MCP guide handle the rest.

Tip — Operation type for subscribers & validation plugins: Handlers and queries have an explicit operation type (CREATE, UPDATE, GETPAGEDLIST, etc.). Subscribers and validation plugins infer the operation from the class/event name (e.g., OnOrderCreated... → Create). If the name is ambiguous, specify the operation explicitly in your prompt: "...for Update operation using Document Store".

---

Document Store (CosmosDB, MongoDB, DynamoDB, RavenDB)

Use when a feature needs to store, retrieve, or query JSON documents in a NoSQL database.

Handler — Create/Update/Delete a document:

Implement the [FeatureName] handler using Document Store for [Create|Update|Delete] operation on [DocumentType] documents

Query — Retrieve documents:

Implement the [FeatureName] query using Document Store to retrieve [DocumentType] documents with filtering and pagination

Subscriber — React to events with document operations:

Implement the [EventName] subscriber using Document Store to [create|update|delete] [DocumentType] documents after the event

Validation Plugin — Validate against document data:

Implement the [FeatureName] validation plugin to check [business rule] against Document Store before [Create|Update]

---

Vector Store (PgVector, Azure AI Search, OpenSearch, Qdrant, Pinecone)

Use when a feature needs similarity search, semantic search, or embedding storage.

Handler — Store embeddings:

Implement the [FeatureName] handler using Vector Store to generate and store embeddings for [EntityType] content

Query — Similarity search:

Implement the [FeatureName] query using Vector Store to find similar [items/documents] based on a search query with optional filters

Subscriber — Auto-index on changes:

Implement the [EventName] subscriber using Vector Store to update the vector index when [EntityType] is [created|updated|deleted]

---

Graph Store (Neo4j, Apache AGE, Amazon Neptune)

Use when a feature needs relationship traversal, path finding, or connected data queries.

Handler — Create graph nodes and relationships:

Implement the [FeatureName] handler using Graph Store to create [NodeType] nodes and [RelationshipType] relationships

Query — Traverse relationships:

Implement the [FeatureName] query using Graph Store to find [connections|paths|recommendations] between [NodeType] entities

Subscriber — Maintain graph on entity changes:

Implement the [EventName] subscriber using Graph Store to update graph nodes/relationships when [EntityType] changes

---

Search Store (Elasticsearch, Azure AI Search, Algolia)

Use when a feature needs full-text search, faceted search, or search indexing.

Handler — Index content:

Implement the [FeatureName] handler using Search Store to index [EntityType] documents for full-text search

Query — Full-text search:

Implement the [FeatureName] query using Search Store to search [EntityType] with full-text, facets, and filters

Subscriber — Auto-index on changes:

Implement the [EventName] subscriber using Search Store to update the search index when [EntityType] is [created|updated|deleted]

---

File Store (Azure Blob, AWS S3, GCP Storage)

Use when a feature needs to upload, download, or manage files in cloud storage.

Handler — Upload/manage files:

Implement the [FeatureName] handler using File Store to [upload|download|delete] files in [container/bucket] organized by [path strategy]

Query — List/check files:

Implement the [FeatureName] query using File Store to list files in [container] with prefix filtering

Subscriber — Process files after events:

Implement the [EventName] subscriber using File Store to [archive|copy|generate] files when [EntityType] is [created|approved|completed]

---

Time Series Store (TimescaleDB, InfluxDB, Azure Data Explorer)

Use when a feature needs to store or query time-stamped measurements, metrics, or IoT data.

Handler — Write data points:

Implement the [FeatureName] handler using Time Series Store to write [metric/measurement] data points with tags and timestamp

Query — Aggregate time series data:

Implement the [FeatureName] query using Time Series Store to aggregate [metric] over [time range] grouped by [interval] with optional tag filters

Subscriber — Record metrics on events:

Implement the [EventName] subscriber using Time Series Store to record a [metric] data point when [EntityType] is [created|updated|state-changed]

---

Cache Store (Redis, Memcached, NCache)

Use when a feature needs caching, session storage, or fast key-value lookups.

Handler — Cache management:

Implement the [FeatureName] handler using Cache Store to [set|invalidate] cache entries for [EntityType] with [duration] TTL

Query — Cache-aside pattern:

Implement the [FeatureName] query using Cache Store with cache-aside pattern — check cache first, fall back to database, then cache the result

Subscriber — Invalidate cache on changes:

Implement the [EventName] subscriber using Cache Store to invalidate cached [EntityType] entries when the entity is [updated|deleted]

---

AI Provider (Azure OpenAI, OpenAI, Anthropic, Gemini, Ollama)

Use when a feature needs chat completions, content generation, classification, embeddings, or streaming AI responses.

Handler — AI-powered operations:

Implement the [FeatureName] handler using AI Provider to [generate|classify|summarize|extract] [content type] from [input]

Handler — Structured output (typed response):

Implement the [FeatureName] handler using AI Provider with structured output to return a typed [ResponseType] from the AI response

Handler — Streaming response:

Implement the [FeatureName] handler using AI Provider with streaming to send incremental AI responses for [use case]

Query — AI-assisted search (RAG pattern):

Implement the [FeatureName] query using AI Provider + Vector Store for RAG — embed the question, search for context, then generate an answer

Handler — Generate embeddings:

Implement the [FeatureName] handler using AI Provider to generate embeddings for [content] and store them in Vector Store

Subscriber — AI processing after events:

Implement the [EventName] subscriber using AI Provider to [classify|summarize|tag] [EntityType] content when it is [created|updated]

Validation Plugin — AI-assisted validation:

Implement the [FeatureName] validation plugin using AI Provider to check [content quality|appropriateness|classification] before [Create|Update]

---

Email Provider (SMTP, SendGrid, AWS SES, Azure Communication Services)

Use when a feature needs to send emails — notifications, confirmations, alerts, or bulk communications.

Handler — Send email directly:

Implement the [FeatureName] handler using Email Provider to send a [notification|confirmation|alert] email to [recipient] after [action]

Handler — Send HTML email with attachments:

Implement the [FeatureName] handler using Email Provider to send an HTML email with [attachments/inline images] for [use case]

Handler — Send templated email:

Implement the [FeatureName] handler using Email Provider to send a templated email using template [templateId] with dynamic data for [use case]

Handler — Bulk email:

Implement the [FeatureName] handler using Email Provider to send bulk emails to [recipient list] for [use case — e.g., newsletter, announcements]

PostBus Plugin — Send email after handler completes:

Implement a PostBus plugin for [FeatureName] using Email Provider to send a [notification|confirmation] email after the handler succeeds

Subscriber — Send email on event:

Implement the [EventName] subscriber using Email Provider to send a [welcome|confirmation|alert] email when [EntityType] is [created|approved|cancelled]

Validation Plugin — Validate email before sending:

Implement the [FeatureName] validation plugin using Email Provider to validate email format and deliverability before [Create|Update]

---

Configuration Notes

All DataStore and Provider integrations follow the same pattern:

• Registration: Each provider is registered in Program.cs / startup using FlexBase's AddFlex[ProviderType]() extension methods

• Environment-specific: Use Console/InMemory providers for development, real providers for production

• Bridge interfaces: Inject the bridge interface (not the raw provider) in handlers, queries, subscribers, and plugins

• Multiple instances: Use keyed registration when you need multiple instances of the same provider type (e.g., two different AI models)

---

Unit Testing (xUnit, NUnit, MSTest)

FlexBase supports 3 test frameworks across 4 test projects. The MCP guides detect which framework to use from the existing .csproj or from the user's prompt.

Feature-Level Tests (All 4 Projects)

Write unit tests for the [FeatureName] feature in the [ModuleName] module using [xUnit | NUnit | MSTest]. Identify ALL components (domain model, mappers, handlers, validation plugins, queries, subscribers) and generate tests across all 4 test projects per FlexBase_UnitTest_Implementation_Guide.

Module-Level Tests (All Features)

Write unit tests for ALL features in the [ModuleName] module using [xUnit | NUnit | MSTest]. For each feature, identify every component and generate tests across all 4 test projects per FlexBase_UnitTest_Implementation_Guide.

DomainModels.Tests — Model & Mapper Tests

Write ALL DomainModels.Tests for [FeatureName] using [xUnit | NUnit | MSTest]: domain model tests (defaults, properties) + Create/Update/Delete mapper tests per FlexBase_UnitTest_Implementation_Guide.

Handlers.Tests — Handler, Subscriber & PostBus Tests

Write ALL handler tests for [FeatureName] in Handlers.Tests using [xUnit | NUnit | MSTest]: Create, Update, Delete handlers. Mock IRepoFactory, test happy path, event firing, and error scenarios per FlexBase_UnitTest_Implementation_Guide.

PreBus.Tests — Validation Plugin Tests

Write ALL validation plugin tests for [FeatureName] in PreBus.Tests using [xUnit | NUnit | MSTest]: Create and Update validation plugins. Test required fields, format validations, and boundary values per FlexBase_UnitTest_Implementation_Guide.

Queries.Tests — Query Tests with DB Strategy

Write ALL query tests for [FeatureName] in Queries.Tests using [xUnit | NUnit | MSTest] with [InMemory EF Core | SQLite | Docker SQL Server | Docker PostgreSQL | Podman]: GetById, GetAll, filtered, paged queries per FlexBase_UnitTest_Implementation_Guide.

Test Data Infrastructure

Create a test data builder for [FeatureName] entity with fluent API. Include sensible defaults, With*() methods, Build() and BuildAndSeed(IRepoFactory). Also create DTO builders per FlexBase_UnitTest_TestData_Infrastructure_Guide.

DataStore/Provider Feature Tests

Write unit tests for [FeatureName] feature using [Document Store | Cache Store | AI Provider | Email Provider | Vector Store] using [xUnit | NUnit | MSTest]. Mock the provider bridge interface per FlexBase_UnitTest_Implementation_Guide.

---

Related

• API patterns: FlexBase API Patterns

• Blazor patterns: Blazor FluentUI

• Angular patterns: Angular UI

• React patterns: React UI