Codebase analysis · CoreStory V3

Tailwind Traders Website

The web storefront of the Tailwind Traders sample retail application: a React client served by an ASP.NET Core host, covering product lists, product detail, shopping cart, coupons and sign-in. Published by Microsoft as a sample.

Maintained by
Microsoft
License
MIT
Commit analyzed
3ffbe85d0e1fe4e2f0ca04798b1f9871ccbc1571
Rules extracted
2026-11-13
Extracted by CoreStory V3
1273
accepted rules, each with a cited source quote
14
capabilities
184
features
01 · Rules

Business rules, traced to source lines.

These 8 rules are a sample of the 1,273 CoreStory V3 extracted from Tailwind Traders Website. Each one links to the exact lines on GitHub at commit 3ffbe85. The statement is CoreStory V3’s wording; the code excerpt is the source it cites.

validation
TailwindTraders.Website/Source/Tailwind.Traders.Web/ClientApp/src/pages/shoppingcart/shoppingCart.js

When updateQty is called with a qty greater than 0, the product quantity is updated via CartService.updateQuantity and the shopping cart state is updated; otherwise the product is deleted via CartService.deleteProduct and the shopping cart state is cleaned.

  • 0 — threshold that distinguishes update from delete
if (qty > 0) { await CartService.updateQuantity(id, qty, this.props.userInfo.token) await this.updateShoppingCartState(id, qty); } else { await CartService.deleteProduct(id, this.props.userInfo.token); await this.cleanShoppingCartState(id, qty); }
quantity increment
TailwindTraders.Website/Source/Tailwind.Traders.Web/ClientApp/src/services/cartService.js

When postProductToCart finds an existing cart product whose id equals detailProduct.id, it updates that product's quantity to product.qty + 1 and resolves with the message "Product added on shopping cart".

  • 1 — increment added to the existing product quantity
  • Product added on shopping cart — message returned on successful quantity update
const product = products.find(product => product.id === detailProduct.id); if (product) { return this.updateQuantity(product._cdbid, product.qty + 1, token) .then(() => ({message: "Product added on shopping cart"})) .catch(() => ({ errMessage: "The product could not be added to the cart" })) }
validation
TailwindTraders.Website/Source/Tailwind.Traders.Web/ClientApp/src/pages/detail/detail.js

A product is shown with the in-stock tag when stockUnits is greater than 0; otherwise it is shown with the out-of-stock tag.

  • 0 — threshold for in-stock vs out-of-stock display
{stockUnits > 0 ? ( <span className="detail__tag">{t("detail.inStock")}</span> ) : ( <span className="detail__tag nostock"> {t("detail.outStock")} </span> )}

Also cited: L49

calculation
TailwindTraders.Website/Source/Tailwind.Traders.Web/ClientApp/src/App.js

If this.state.shoppingCart is not null, compute quantity as the sum over shoppingCart items of each item's qty starting from an initial accumulator of 0, then set state.quantity to that sum.

  • 0 — initial accumulator for the quantity reduce
if (this.state.shoppingCart != null) { const quantity = this.state.shoppingCart.reduce( (oldQty, { qty }) => oldQty + qty, 0 ); this.setState({ quantity }); }
access control
TailwindTraders.Website/Source/Tailwind.Traders.Web/ClientApp/src/App.js

A PrivateRoute renders the wrapped component only when this.props.userInfo.loggedIn === true; otherwise it redirects to "/".

  • true — required value of userInfo.loggedIn to render the component
  • / — redirect target when not logged in
this.props.userInfo.loggedIn === true ? ( <Component {...props} {...rest} /> ) : ( <Redirect to="/" /> )

Also cited: L76–L79

validation
TailwindTraders.Website/Source/Tailwind.Traders.Web/ClientApp/src/helpers/errorsHandler.js

An error is treated as a token-expired error when the error has a response with HTTP status 401, or when the response data is a string matching the regular expression /401|[Uu]nauthorized/; otherwise it is not a token-expired error.

  • 401 — HTTP status that makes the error a token-expired error
  • /401|[Uu]nauthorized/ — regular expression matched against string response data, matching '401' or 'Unauthorized'/'unauthorized'
function isTokenExpiredError(error) { if (error.response && error.response.status === 401) { return true; } if (error.response && error.response.data) { const errorResponseData = error.response.data; if (typeof errorResponseData === 'string') { return !!errorResponseData.match(/401|[Uu]nauthorized/); } } return false; }

Also cited: L8–L10

limit
TailwindTraders.Website/Source/Tailwind.Traders.Web/ClientApp/src/pages/home/homeContainer.js

Popular products are limited to the first 3 items via slice before being stored in state, and loading is set to false.

  • 3 — maximum number of popular products retained
  • false — loading state set after popular products are retrieved
if (popularProducts && popularProducts.data.popularProducts) { popularProducts = popularProducts.data.popularProducts.slice(0, 3); this.setState({ popularProducts, loading: false }); }
validation
TailwindTraders.Website/Source/Tailwind.Traders.Web/Standalone/Controllers/LoginController.cs

The login request is rejected with BadRequest("Could not verify username and password") if the Username is null, empty, or whitespace, OR the Password is null, empty, or whitespace, OR the GrantType is not equal to "password".

  • password — required grant type value
if (string.IsNullOrWhiteSpace(request.Username) || string.IsNullOrWhiteSpace(request.Password) || request.GrantType != "password") { return BadRequest("Could not verify username and password"); }
02 · Capabilities

What the application does

14 capabilities identified, grouping 182 of the 183 distinct features extracted. These are descriptions, not the cited rules above.

Web User Interface and Application Shell

The web front end shell and reusable UI components that render the Tailwind Traders experience, including headers, grids, cards, chat, video, and meetings.

  • Adaptive Card Posting to User: Posts an adaptive card directly to a user as the Flow bot within a conversation.
  • Application Header Display: Renders the application's header UI, including its visibility state, for the user.
  • Button Actions: Provides primary, floating, and reset button styles for user-triggered actions within the container.
  • Call Participation Card: Displays a call card for a remote participant, subscribing to their presence and reacting when the call finishes connecting.
  • Card Item Listing: Displays items as cards with photos in list or grid layouts.
  • Chat Bubble Display: Renders a chat message as a visual bubble in the conversation UI.
  • Chat Display: Renders the chat component's user interface for users to view.
  • Checkbox Group Display: Renders a container of checkbox options for user selection.
  • Code Container Display: Renders a code container layout with a collapsible aside, content area, and panel for presenting code or documentation.
  • Debug Header Display: A UI header component that displays debug information to the user.
  • Diagram Application Display: A user-facing application view that connects to application state and renders the diagram interface.
  • File Upload: A user-facing component that lets users select and submit a file for upload, with rendering and state reset behavior.
  • Filter Panel Toggle: A user can open a filter panel from the list aside to reveal filtering controls.
  • Font Face Definition: Generates @font-face declarations for embedding fonts with specified source, format, weight, and style.
  • Font Inclusion: Includes font files by resolving font paths, extensions, and names into usable font sources.
  • Grid Display: Renders a grid view for users.
  • Hero Display: Renders a hero section component for the user interface.
  • Home Page: Landing page presenting hero highlights, popular and recommended products, and mobile app download.
  • Home Page State Binding: Connects the home container to application state and controls re-rendering.
  • List Aside Display: A sidebar/aside listing is rendered and initialized for the user.
  • Local Video Preview: Displays a local camera preview to the user within the video card component.
  • Media Stream Display: Renders a streaming media component, including its lifecycle setup and teardown, so a user can view streamed media.
  • Meeting Display: Renders a meeting UI component to present meeting information to the user.
  • Meeting Lifecycle Management: Initializes and mounts the meeting component so it becomes active and visible within the application.
  • Photo Upload Banner: Promotional banner inviting users to upload a photo.
  • Popular Products Display: Renders and manages the home page's popular products view within the HomeContainer.
  • Remote Participant Card Display: Renders a card representing a remote participant in a call or session.
  • Remove Remote Participant: Allows a user to remove a remote participant from the session via the participant card.
  • Suggested Products Display: A React component lifecycle that mounts and renders a list of suggested products for the user.
  • Task Runner: Provides a way to define, build, run, and watch named tasks from a tasks container.
  • User Portrait Display: Renders a visual user portrait for display to the user.
  • Web Application: A web-facing user interface layer exposed by the system.
  • Web Application Hosting: Bootstraps and runs a hosted web application for the Tailwind Traders web front end.

Build and Deployment Pipeline

CI/CD workflows that check out source, compile and package .NET/Node/SPA projects, build and push container images, and perform scheduled or on-demand deployments.

  • Artifact Staging Upload: Uploads deployment artifacts into a storage account container from a staging directory.
  • Artifact Staging and Deployment: Computes artifact staging locations and copies build products and deployment project content into an artifact staging directory.
  • Autobuild: Automatically builds the project as part of the analysis workflow to enable code scanning.
  • Azure Web App Deploy: Deploy the built application to an Azure web app.
  • Build and Deploy: Builds and deploys the telephony bot via a checkout-based CI pipeline.
  • Build and Deploy Pipeline: End-to-end CI/CD capability that checks out code, builds and pushes an image, then deploys it.
  • Build and Publish .NET App: Build and publish the .NET application as part of the deployment pipeline.
  • CI Job Definitions: Defines the individual continuous-integration jobs (main, nightly, and pull-request builds) that run automated builds.
  • Clean Build Output Management: Removes binary and intermediate output folders to clean the project build state.
  • Client App Dependency Install: Install dependencies for the client application.
  • CodeQL Security Analysis: Runs automated CodeQL static analysis on the repository to detect security vulnerabilities.
  • Container Build Configuration: Ability to configure the container build, including the image, version, environment, ports, and Dockerfile used to build it.
  • Container Context Configuration: Ability to specify the build context for the container.
  • Container Image Build and Push: Builds a Docker container image and pushes it to a registry for later deployment.
  • Content and Output Item Copying: Copies content and other project items to the output directory based on per-item copy directives.
  • Docker Build: Builds the project's Docker image within the build pipeline.
  • Docker Build and Push: Builds a container image and publishes it to a registry for later deployment.
  • GitHub Action Checkout: Checks out the repository code in a GitHub Actions build job.
  • Main Branch Build: A build run against the main branch to validate integrated code.
  • Manifest Resource Generation: Creates manifest resource names for the project's embedded resources.
  • Nightly Build and Deploy: A scheduled build that also deploys the application to an environment.
  • Node Build and Test: Sets up Node, installs dependencies, builds, and runs tests for the project.
  • Node Environment Debug Check: Validates the Node.js environment when debugging the application.
  • Project Build: Compiles/builds the project as part of the build job.
  • Project Capability and Schema Definition: Defines the project's capabilities, item schemas, and extension configuration used by the build system.
  • Project Compilation: Compiles a project (or deployment project) into build outputs according to configuration, platform, and target runtime settings.
  • Pull Request Build: A build triggered on pull requests to validate proposed changes.
  • Referenced Project Output Handling: Gathers and stages the output artifacts produced by referenced projects, including explicit assembly references.
  • Repository Checkout: Fetches the repository contents into the CI job environment so subsequent steps can operate on the code.
  • SPA Webpack Publish: Builds and publishes Single Page Application assets via webpack during the MSBuild publish pipeline.
  • TypeScript Tooling Configuration: Configures TypeScript compilation tooling for the project.

Bot Conversation and Dialog Engine

Authoring, composing, and executing bot dialogs including triggers, events, control flow, prompting, entity handling, memory, external calls, and QnA/recognition.

  • Activity Messaging: Sending, tracing, and logging activities to converse with the user and emit conversation events.
  • Adaptive Dialog: Author and run a declarative adaptive dialog with triggers, recognizers, and language generation.
  • Adaptive Dialog Debugging: Debugging and inspecting adaptive dialog execution via breakpoints and action editing.
  • Bot Skill Invocation: Invoke a remote bot skill and continue a conversation with that skill later.
  • Control Flow: Conditional branching, looping, and exception handling within dialog logic.
  • Conversation Flow Control: Conditionally branch, loop, and iterate over actions using if/else, switch, foreach, and break/continue constructs.
  • Dialog Authoring and Composition: Building and structuring bot conversation flows by nesting, reusing, and controlling dialogs.
  • Dialog Debugging: Set debugger breakpoints and stepping behavior while authoring dialogs.
  • Dialog Event Emission and Handling: Emit custom dialog events and trigger action sequences in response to activity, intent, event, and dialog lifecycle events.
  • Dialog Invocation and Lifecycle: Begin, replace, repeat, cancel, or restart child dialogs and end the current dialog or turn.
  • Entity Assignment and Property Filling: Assign recognized entities to properties and resolve which entity or property the user means to fill.
  • Error and Exception Handling: Raise exceptions and handle errors through dedicated error trigger flows.
  • External Service Integration: Calling external HTTP endpoints and invoking remote skills from within a dialog.
  • HTTP Request Execution: Perform outbound HTTP calls from within the dialog and read the response.
  • Intent and Event Recognition: Triggering dialog logic in response to recognized intents and activity or lifecycle events.
  • Memory Property Management: Get, set, and delete dialog memory properties and execute arrays of property assignments.
  • Multi-language Response Generation: Generate localized responses using language policies, resource generators, template engines, and text templates.
  • Prebuilt Entity Extraction: Extract built-in entity types such as numbers, dates, money, emails, dimensions, and mentions from user input.
  • Prompted User Input Collection: Prompt the user and collect typed input such as text, number, confirmation, choice, date/time, attachment, or OAuth credentials with validation and reprompting.
  • Property and Memory Management: Setting, deleting, and enumerating bot memory properties during a conversation.
  • QnA Maker Knowledge Answers: Answer user questions from a QnA Maker knowledge base within the dialog flow.
  • String Replacement: Replaces occurrences of a search string with a replacement within a target string.
  • Telemetry Event Tracking: Emit custom telemetry events from within the dialog flow.
  • Text and Intent Recognition: Recognize user utterances into intents and entities using regex, LUIS, QnA Maker, and multi-language recognizer sets.
  • Trigger Selection Strategy: Select which dialog trigger to fire using first, random, conditional, most-specific, and true selectors.
  • User Input Prompting: Asking the user for typed input such as text, numbers, choices, confirmations, dates, and attachments.

Azure Infrastructure Provisioning

Creating and deploying Azure resources and bot infrastructure including App Service hosting, storage, Cosmos DB, Cognitive/LUIS/QnA services, container registry, and ARM template deployment.

  • App Service Plan Management: Creates a new App Service Plan or reuses an existing one for hosting the deployed web applications.
  • Application Insights Monitoring: Deploys an Application Insights component that provides telemetry and monitoring for the provisioned applications.
  • Application Insights Monitoring Setup: Creates optional Application Insights telemetry resources for the deployed bot.
  • Azure Resource Deployment: Create, validate, and provision Azure resource deployments with deployment templates and error reporting.
  • Blob Storage Provisioning: Provisions a storage account with blob storage for bot data storage.
  • Bot Service Provisioning: Deploys an Azure Bot Service instance with its messaging endpoint, app credentials, and SKU.
  • Bot Service Registration: Registers the bot application and exposes its endpoint, app identity, and secret for bot channel integration.
  • Cognitive Services Account Provisioning: Defines and deploys a Cognitive Services account with a selected SKU, name, and optional personalizer settings.
  • Container Registry Provisioning: Defines and deploys an Azure Container Registry with a chosen registry SKU and registry URL.
  • Cosmos DB Provisioning: Provisions an optional Cosmos DB account and database for bot state and data storage.
  • LUIS Language Model Provisioning: Provisions LUIS authoring and runtime resources for natural-language understanding.
  • LUIS Language Understanding Provisioning: Provisions and configures LUIS authoring and runtime services with their keys, locations, and SKUs for bot language understanding.
  • QnA Maker Deployment: Provisions a QnA Maker knowledge base service along with its search service and web app via ARM templates.
  • QnA Service Deployment: Create and validate QnA Maker service deployments using QnA-specific template parameters.
  • Storage Account Provisioning: Provisions an optional blob storage account for the bot.
  • Template Deployment Validation: Validates Azure Resource Manager templates against parameter files with a validate-only option producing validation output.
  • Web App Configuration: Supplies application settings and resource configuration required to wire up the deployed web apps.
  • Web App Hosting: Provisions an App Service plan and site to host a web application, including site name and worker size.
  • Web App Hosting Deployment: Deploys the bot to an App Service plan and web app, supporting new or existing plans and locations.

Product Catalog and Discovery

Browsing, searching, filtering, and viewing product details within the storefront, including category and brand taxonomies, images, and site navigation.

  • Category Browsing: Exposes the product category catalog the ranking feature operates over, covering electrical, garden center, plumbing, and power tools.
  • Product Browsing: Accessing product data via the product service to display catalog products to users.
  • Product Catalog Browsing: Users can retrieve and browse the product catalog through the GetProducts operation.
  • Product Detail: Product detail view showing stock availability, tags, and adding an item to the cart.
  • Product Detail Display: Renders a product detail page, including fetching detail page data on mount and update and mapping application state for display.
  • Product Filtering by Category and Brand: Filter products by product type codes and brand ids.
  • Product Image Display: Resolves and exposes product image URLs so product visuals can be shown to users.
  • Product List Display: Renders a paginated, query-string-synced list of products that fetches product data and updates as the user navigates pages.
  • Product Listing: Retrieves and displays the catalog of products to the user.
  • Product Listing and Filtering: Browsable product list with filter and sort controls for brands, price, and rating.
  • Product Search Results Display: Presents matched products to the user with identity, name, price, and image so search results can be browsed.
  • Product Suggestion Display: Presents a list of suggested products as card items with photos and quick-action buttons.
  • Site Navigation and Categories: Shared header and footer navigation across product categories and informational links.

Runtime Configuration and Backend Services

Application bootstrap, settings, runtime configuration, schema management, notifications, and shared backend service layer.

  • Application Provisioning: Provision and create application instances through a CLI or app entry point.
  • Application Settings Configuration: Exposes a consolidated configuration surface covering shopping cart API, B2C authentication, Azure Communication Services, Application Insights, and personalizer integrations.
  • Application Startup Configuration: The ASP.NET Core web application bootstraps itself, wiring up services and middleware through its Startup configuration.
  • Backend Services: Service layer providing the application's backend capabilities.
  • Container Service Management: Ability to define and manage containerized services alongside the web application.
  • Email Subscription: Header email signup for newsletter or notifications.
  • Runtime Configuration: Exposes runtime state/configuration that the system or user relies on when operating the schemas.
  • SMS Sending: Sends an SMS message to a user's phone number via Azure Communication Services.
  • Schema Backup: Captures and restores backup copies of the data and UI schema files alongside the primary schema definitions.
  • Standalone Mode: Enables the application to run in a standalone configuration, with support for adding, enabling, and activating standalone operation via configuration.
  • Standalone Web Application: A standalone web application container that hosts user-facing functionality for Tailwind Traders.
  • Teams Meeting Creation: Creates a Microsoft Teams meeting, optionally as a video call, using a configured Teams connection.

Authentication and Identity

User and service authentication including login, sign-out, B2C/Azure sign-in, token issuance, session and token lifecycle management, and subscriber registration.

  • Access & Refresh Token Management: Stores and retrieves access and refresh tokens for authenticated sessions.
  • Access Token Retrieval: Provides a client with an access token, its expiry, and token type so it can authenticate subsequent requests.
  • Authentication Session Management: Handles unauthenticated requests and refreshes access tokens so a caller's request can proceed after re-authentication.
  • Azure Authentication: Users can log in to Azure via the CLI and log out of their Azure session.
  • Azure CLI Login: Authenticates the CI runner against Azure using the Azure CLI before deployment.
  • B2C Login: Enables a business-to-consumer user to authenticate and sign in to the system.
  • Subscriber Registration: Registers a new subscriber with the system.
  • Token Acquisition and Request Retry: Fetches new JWT tokens and retries the original request once credentials become available.
  • Token Expiration Handling: Detects expired authentication tokens and produces an error response so callers can react to session expiry.
  • User Login: Authentication entry point with login, B2C and Microsoft sign-in options.
  • User Sign Out: Sign the current user out of an authenticated connection.

Coupons and Promotions

Viewing, favoriting, and recommending coupons and promotional content to users.

  • Coupon Display: Renders coupon cards with associated details for users to browse.
  • Coupon Favorites: Lets users mark and view favorite coupons.
  • Coupon History: Shows users a history of their coupons.
  • Coupon List Display: Renders a user's coupons in a grid container with a title, subtitle, and disclaimer.
  • Coupons: Viewing and managing user coupons, including a dedicated coupons page and profile coupon section.
  • My Coupons: Displays the current user's coupons by wiring application state into a coupons container component.
  • Recommended Coupons: Presents recommended coupons to the user.
  • View My Coupons: Lets a user retrieve and see the coupons they hold.

Recommendations and Personalization

Personalized product ranking, recommendations, reranking, and reinforcement feedback via the personalizer service.

  • Personalizer Reward Feedback: Submits reward feedback to the personalizer to reinforce or correct previously ranked recommendations.
  • Product Ranking Recommendation: Powers a personalized ranking of product categories by sending a rank request through a personalizer client from the controller.
  • Product Recommendations: Surfaces recommended products to users based on the current context.
  • Product Reranking: Computes a rank and produces reranked products for display.
  • Recommended Item Display: Presents a recommended item to the user as part of the reward flow.
  • Reward Submission: Allows a user to trigger a reward action and have it posted to the backing service.

Shopping Cart and Checkout

Managing a user's shopping cart including adding products, updating quantities, persistence, and cart views.

  • Add Product to Cart: Allows a user to add a product to the shopping cart from the detail page, with success and error feedback.
  • Shopping Cart: Cart view where users review and manage items they intend to purchase.
  • Shopping Cart Card Display: Renders a shopping cart card view for the user.
  • Shopping Cart Lifecycle Initialization: Initialization and teardown of shopping cart state when the cart view is mounted and unmounted.
  • Shopping Cart Management: A user-facing shopping cart component that displays cart contents and lets users update item quantities.
  • Shopping Cart Persistence: Provides storage and retrieval of a user's shopping cart items so cart contents survive across sessions.

Application State and Persistence

Storing and retrieving application state and data across SQL, MongoDB, key-value access, and standalone initialization.

  • Key-Value Item Access: Reading and writing individual named items stored within the application state.
  • MongoDB Persistence: Persistence of application data in a MongoDB store.
  • Persistent State Storage: Saving and loading application state to and from persistent storage.
  • SQL Database: Persistence of application data in a SQL database.
  • Standalone Database Initialization: A self-contained initializer that creates the application's schema tables and seeds them with initial data when the database is empty.

Image-Based Search and Recognition

Searching and classifying by uploaded image using image recognition, term prediction, and search services.

  • Image Classification: Uploading an image to receive an AI-generated classification result from the classifier service.
  • Image Recognition: Recognizes image content and produces an image recognition result for downstream consumption.
  • Image Search: Searching for products using an uploaded image through the image search service.
  • Image Search Term Prediction: Predicts search terms for images, exposing a prediction capability through the IImageSearchTermPredictor contract and PredictSearchTerm implementation.
  • Search Term Prediction: Predicts likely search terms for an image using a remote prediction endpoint and returns ranked prediction scores.

User Profile and Purchase History

User profile pages and account information alongside past purchase records and personalized sections.

  • Add to List: Capability to save a product to a user's list.
  • Purchase History: Provides users access to their past purchase records as a retrievable history.
  • User Profile: Customer profile page showing personal details and sections for favorites, history, and recommendations.
  • User Profile Viewing: Exposes an endpoint that lets a user retrieve their own profile details.

Kubernetes and Helm Deployment

Deploying applications to Kubernetes clusters using Helm charts and targeting the correct cluster context.

  • Helm Chart Deployment: Deploys an application to a Kubernetes cluster by installing a Helm chart.
  • Helm Installation: Installs the Helm CLI so charts can be deployed to a cluster.
  • Kubernetes Context Selection: Sets the kubectl context to target a specific AKS cluster for subsequent operations.
03 · Size

What was analyzed

  • JSON · 26 files · 22,151 lines
  • JavaScript · 76 files · 4,516 lines
  • SCSS · 35 files · 2,577 lines
  • Markdown · 12 files · 2,370 lines
  • C# · 35 files · 1,389 lines
  • YAML · 18 files · 518 lines
  • PowerShell · 4 files · 257 lines
  • SVG · 27 files · 176 lines
  • XML · 3 files · 145 lines
  • Dockerfile · 3 files · 69 lines
  • CSS · 4 files · 60 lines
  • Other (6 languages) · 9 files · 224 lines

Whole repository: 346 files. cloc 2.06 counts 34,452 lines of code in 252 of them (37,637 lines with comments and blanks).

04 · Source

Where this came from

Extracted by CoreStory V3 (build 4470 with two small engine fixes) using DeepSeek-V4.1-Flash from the public repository at commit 3ffbe85 on 2026-11-13. Capability descriptions are from the same run.

Code excerpts are from the upstream repository and remain under its MIT license. CoreStory is not affiliated with or endorsed by Microsoft.

Want this for your own codebase?

Talk to us about mapping the business rules in your repositories.

Talk to an expert