Glossary
A comprehensive reference of terms, concepts, and technical vocabulary used throughout the Mockomat documentation. Terms are grouped by category and sorted alphabetically within each group.
Platform & Product
Blueprint A pre-built Mockomat project template covering a common domain pattern (e.g., E-Commerce, CRM, Blog). Blueprints can be cloned into a workspace and customized. See Blueprints.
Domain Model The semantic foundation of a project. Defines entities, attributes, and relations that describe the structure and meaning of your data before any API or implementation detail is decided.
Domain Slice A small, coherent subset of your business model — typically one or two related entities used as a starting point for modeling.
Mockomat A multi-tenant SaaS platform for domain modeling, mock API simulation, and backend code generation. Users define schemas visually, map data, and get live GraphQL APIs instantly.
Project A complete mock API definition that includes a domain model, data mappings, API configuration, and associated mock data. Each project has a unique slug and endpoint.
Workspace The central environment where users build, configure, validate, and iterate on a mock API project. Contains the modelling board, table editor, API design view, and runtime preview.
Modeling
Attribute A field or column of an entity. Each attribute has a name, type (string, number, boolean, date, json), and configuration flags that control API behavior.
Cardinality The quantitative relationship between entities: one-to-one (1:1), one-to-many (1:n), or many-to-many (m:n).
Entity / Table A core business concept represented in the model (e.g., Customer, Order, Invoice). Visualized as a table card on the modelling board.
Filterable An attribute flag that enables filter operations on the field in GraphQL queries. Only filterable fields accept filter expressions.
Hint An actionable signal in the preview that alerts users to model issues — unmapped attributes, configuration mismatches, or missing relation targets.
Modelling Board The visual canvas in the workspace where entities are created, positioned, and connected through drag-and-drop interaction.
Naming Convention Standardized patterns: PascalCase singular for entities (e.g., Customer), camelCase for attributes (e.g., firstName).
Relation A connection between two entities that defines how data flows between them. Has a direction (source → target) and cardinality (1:1, 1:n, m:n).
Required An attribute flag indicating the field must always have a value. Affects GraphQL nullability in the generated schema.
Searchable An attribute flag that includes the field in search query resolution.
Sortable An attribute flag that enables sort operations on the field. Only sortable fields can be used in sort parameters.
Table Card The visual representation of an entity on the modelling board, showing the table name, columns, relation indicators, and action buttons.
Table Editor The configuration panel that opens when selecting a table on the modelling board, providing detailed attribute and relation setup.
Data Sources & Mapping
CONST A data mapping type that assigns a fixed, constant value to every record (e.g., "active" for a status field).
Data Mapping The configuration that links an entity attribute to a data source, determining what values the field returns at runtime.
Data Object A semantic field definition with tags and sample data, used as the source for OFF_FIELD mappings. Part of the semantic corpus.
Dataset A collection of real-world data (e.g., product catalogs from Open Food Facts) that can be mapped to attributes via OFF_FIELD mapping.
FAKE A data mapping type that uses Faker to generate realistic synthetic data — names, emails, addresses, dates, prices, and more.
Faker An open-source library that generates realistic synthetic data following real-world patterns (proper name formats, valid email structures, realistic prices).
OFF_FIELD A data mapping type that maps an attribute to a field from a real-world dataset (e.g., Open Food Facts), producing realistic and diverse values.
Synthetic Data Data generated by Faker that mimics real patterns but is fictional, never derived from production sources.
API & GraphQL
API Contract The formal specification of query names, field structures, and operation availability that external consumers depend on.
API Design View A workspace area where users control which GraphQL operations are exposed and how queries are named.
Code-First GraphQL The approach used by Mockomat where GraphQL schemas are generated from model definitions and decorators rather than written manually as SDL files.
Detail Query A GraphQL query that returns a single record by its identifier (e.g., product(id: "abc-123")).
Dynamic Schema Generation The process where Mockomat generates a fully typed GraphQL schema on-the-fly from a project's model definitions.
Endpoint The URL path where consumers query a mock API: POST /mock/{slug}/graphql.
Filter Expression A condition or set of conditions used to narrow query results. Supports boolean algebra with AND/OR operators and nesting.
Filter Operator A comparison operation used in filter expressions: EQ, NE, LT, GT, LE, GE, LIKE, IS_NULL, IS_NOT_NULL.
GraphQL The query language and API design pattern used by Mockomat for both the management API and mock runtime endpoints.
List Query A GraphQL query that returns a paginated collection of records with optional filtering and sorting (e.g., products(limit: 20)).
Offset-Based Pagination The pagination method used by Mockomat: offset (items to skip) + limit (items to return).
Operation Exposure The configuration of which GraphQL operations (list, detail) are available for each entity.
Query Naming The custom naming of GraphQL entry points — list queries default to plural (e.g., products), detail queries to singular (e.g., product).
Slug / Project Slug A URL-safe identifier for a project used in the API endpoint path (e.g., customer-portal → /mock/customer-portal/graphql).
Runtime
Aggregation Pipeline MongoDB's multi-stage data processing framework, used by the runtime query builder to execute queries, filters, sorts, and relation lookups.
Mock Runtime / Runtime Engine The core engine that accepts GraphQL queries and translates them into MongoDB operations through a four-stage pipeline: parse → plan → build → assemble.
MongoDB Query Builder The third stage of the runtime pipeline that translates an execution plan into a MongoDB aggregation pipeline.
Preview The in-app runtime interface where users test their model with live queries and inspect response data alongside readiness hints.
Query Planner The second stage of the runtime pipeline that analyzes a parsed query alongside model metadata to create an execution plan.
Relation Traversal The runtime's ability to simulate relational data from flat MongoDB collections by building lookup stages in the aggregation pipeline.
Request Parser / GraphQL Request Parser The first stage of the runtime pipeline that parses an incoming query string into an abstract syntax tree (AST).
Result Assembler The fourth stage of the runtime pipeline that reshapes MongoDB results into the expected GraphQL response structure.
Runtime Validation The process of confirming that a model's domain and API decisions behave correctly under real query execution.
Views Different perspectives on the same model — board view, table detail view, API design view, runtime preview — navigable via cross-links.
Export & Code Generation
Code Generation / Codegen The automated process of creating a working backend project from a Mockomat domain model.
Controller The REST API layer in generated NestJS code, exposing HTTP endpoints with route decorators and Swagger annotations.
DTO (Data Transfer Object) Structured objects with class-validator decorators (@IsString(), @IsNumber(), @IsOptional()) that enforce input validation in generated backends.
Export The feature that generates a production-ready NestJS backend from a Mockomat project. The generated code is 100% owned by the user.
Generated Backend A complete NestJS project produced by the export feature — modules, controllers/resolvers, services, entities, DTOs, and configuration.
Mongoose An ODM (Object-Document Mapping) library for MongoDB, available as a persistence option in generated backends.
NestJS The Node.js framework used as the primary code generation target. Generated backends follow standard NestJS conventions.
Resolver The GraphQL API layer in generated NestJS code, exposing query and mutation endpoints using GraphQL decorators.
TypeORM An ORM (Object-Relational Mapping) library for SQL databases (PostgreSQL, MySQL, MariaDB), available as a persistence option in generated backends.
Authentication & Security
Actor Token A time-limited token issued to external API consumers for concurrency tracking. Included via the X-Actor-Token header.
API Key A credential issued per project to authenticate external consumers against private mock API endpoints. Included via the Authorization: Bearer header.
Concurrent Session A simultaneously active authenticated user connection. Each plan tier has a maximum concurrent session limit.
JWT (JSON Web Token) A token format used for stateless authentication in the Mockomat management API.
Private Endpoint A mock API endpoint that requires API key authentication, available on Business plans and above.
Public Endpoint A mock API endpoint accessible without authentication, subject to per-IP rate limiting.
Rate Limiting The system that enforces request limits per billing period. Returns HTTP 429 (Too Many Requests) with a Retry-After header when exceeded.
Session An authenticated browser connection that counts toward the tenant's concurrent session limit.
SSO / SAML Single Sign-On and Security Assertion Markup Language — enterprise identity management protocols (planned feature).
Plans & Access
Business (Plan) A paid tier ($19/month) offering private endpoints, API keys, role-based access, 50,000 requests/month, and up to 25 projects.
Business Pro (Plan) A paid tier ($49/month) adding multi-user teams, endpoint analytics, 250,000 requests/month, and unlimited projects.
Enterprise (Plan) A custom-priced tier offering unlimited requests, custom datasets, SSO/SAML, SLAs, on-premise deployment, and configurable session limits.
Free (Plan) A free tier requiring account registration, offering up to 5 projects, 1,000 requests/day, and public endpoints.
Quick (Plan) The instant, no-login tier offering one temporary session-based project with a public endpoint. Work is lost when the browser session ends.
Team & Governance
Admin A user role with full access to projects, team management, and tenant configuration.
Domain Ownership Assigned responsibility for a specific business domain area and its model definitions within the team.
Governance Policies and controls ensuring consistency, quality, and compliance across team modeling efforts — naming conventions, review gates, and validation criteria.
Guest A user role with read-only access to shared projects and preview.
Multi-Tenancy The system architecture that isolates each organization's data, schemas, and configuration through tenant-scoped access.
Review Gate A mandatory checkpoint where model, API, or export changes are validated before promotion — e.g., pre-export runtime validation.
Tenant An isolated organizational boundary with dedicated data collections, independent configuration, and separate rate limiting.
User A user role that can create, edit, and export projects within the team.
User Admin A user role that can manage team members and assign roles without full admin access.
Infrastructure & Deployment
Data Sovereignty The requirement that all data remains within a customer's own infrastructure, addressed by the on-premise deployment option.
Docker Containerization technology used to package and deploy Mockomat instances.
On-Premise Deployment A self-hosted Mockomat installation running on the customer's infrastructure for complete data control ($1,000 setup + $199/month).
SLA (Service Level Agreement) A formal commitment to availability, response times, and support levels for Enterprise customers.