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 ready-made Mockomat project for a common domain (Users & Profiles, E-Commerce, Cars & Vehicles, Real Estate, Furniture & Home, Food & Restaurants). 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 mock API definition: a domain model, its data mappings and its API configuration. Each project has a unique slug and its own mock API endpoint.
Workspace A group of projects inside your account. Every account has one workspace; Professional and above can create more. The Workspace section of these docs covers the modelling board, table editor, API design view and runtime preview.
Modeling
Attribute A field of a table. Each attribute has a name, a type (e.g., String, Integer, Float, Boolean, Date, JSON, Enum), a data mapping and flags such as Required and Searchable.
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 stored with the model. The mock runtime does not read it: filtering uses the parameters of an operation (see API Design).
Hint A message in the runtime preview that explains why a table shows no data or what to configure next — for example, that a table is not mapped to imported data.
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 have a value. The OpenAPI export lists it as a required property.
Searchable An attribute flag that includes the field in the case-insensitive searchTerm search of list operations.
Sortable An attribute flag stored with the model and used for the list columns of code export. The mock runtime does not read it: sortField accepts any attribute bound to a data column.
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
COMPUTED A mapping type that stores an expression over other fields of the same record. The runtime does not evaluate expressions, so a computed field is not part of the response. The attribute editor no longer offers Computed; an attribute that already has a Computed mapping keeps it and is marked as not evaluated.
CONSTANT A mapping type that pins one fixed value on an attribute (e.g., "active" for a status field); the runtime returns it on every row, on rows of imported data and on rows composed from value pools alike.
Data Mapping The configuration that links an entity attribute to a data source, determining what values the field returns at runtime.
Data Object A column of a table in Mockomat's data pool, offered in the mapping pane when you bind an attribute with a SOURCE mapping.
Dataset A body of data that Mockomat imports into its data pool — open data where a vetted source exists, generated sample data for the blueprints; attributes read its columns through SOURCE mappings.
SOURCE (Data Source) A mapping type that binds an attribute to a column of the imported datasets in Mockomat's data pool; the runtime serves the imported rows and never invents values.
Value Pool A table of context-free values (first names, streets) that other tables compose their rows from — coherent combinations, never invented values.
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 scope filter or operation parameter that narrows query results. All conditions of an operation combine with AND.
Filter Operator A comparison used by parameters and scope filters: eq, neq, gt, gte, lt, lte, in, like; scope filters also notIn, isNull, isNotNull.
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(page: 1, pageSize: 20) { items { … } total }).
Page-Based Pagination The pagination method used by Mockomat: page (page number, from 1) + pageSize (records per page, at most 100).
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.
DTO (Data Transfer Object) The create and update input classes of a generated backend, one pair per table, with class-validator decorators.
Export The feature that writes a project as an OpenAPI specification or, from Professional on, as a generated NestJS code package. The generated code is owned by the user. See Export.
Generated Backend The NestJS project in a code package — one module per table with entity, resolver, service and inputs, plus authentication and configuration.
NestJS The Node.js framework of generated backends. Generated code follows standard NestJS conventions.
Resolver The GraphQL API layer in generated NestJS code: the queries and mutations of one table.
TypeORM The ORM (Object-Relational Mapping) library of generated backends; generated entities target MySQL / MariaDB.
Authentication & Security
Actor Token An optional, time-limited token that tells the consumers of one API key apart for concurrency tracking. Sent in the X-Actor-Token header.
API Key A credential issued per project to authenticate external consumers against that project's mock API — required for every project in an account. Sent in the Authorization: Bearer header (or X-API-Key); API keys come with the Professional plan and above.
Concurrent Session Being signed in on more than one device or browser at the same time. On Starter, an account can be signed in in one place at a time: signing in elsewhere ends the earlier session. On Professional, Business and Enterprise, the account owner can stay signed in on several devices at once. Invited members do not get this from the account they join: they are signed in in one place at a time unless they own an account whose plan allows more.
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 — the endpoint of every project in an account.
Public Endpoint A mock API endpoint reachable without an API key. Only guest projects have one: it opens with the project's share token and is subject to per-IP rate limiting.
Rate Limiting The limits on mock API requests: a per-IP rate limit and the request quota of your plan (per day or per calendar month). Both answer HTTP 429 (Too Many Requests) when exceeded; the per-IP limit also sends a Retry-After header.
Session One sign-in on one device or browser. A session ends when you sign out, after a period without activity, or when your password changes.
Plans & Access
Billing Portal The secure Stripe page where the owner of a workspace account switches plans, updates the payment method and billing details, and downloads invoices. Opened from Account → Billing.
Business (Plan) A paid tier, billed monthly, that extends Professional with larger teams, more maintainers, and endpoint analytics.
Enterprise (Plan) A tier arranged with our sales team (pricing on request, no self-serve checkout); its limits — projects, requests, team size — are adjusted per contract.
Guest (Plan) The instant, no-login tier offering one temporary session-based project whose endpoint opens with its share token. The work is kept in the browser for a limited time; when you sign up, the app offers to move it into your account.
Professional (Plan) A paid tier, billed monthly, offering private endpoints, API keys, role-based team access, and a monthly request quota.
Starter (Plan) The free tier requiring account registration, with persistent projects and a daily request quota in the app; calling the mock API from your own code needs API keys (Professional and above).
Current limits per plan are on the pricing page and in Account and Plans.
Team & Governance
Domain Ownership Assigned responsibility for a specific business domain area and its model definitions within the team.
Editor A workspace role that builds the model, creates projects, manages API keys and runs code export (labelled editor in the API). Includes everything a Reporter can do.
Governance Policies and controls ensuring consistency and quality across team modeling efforts — naming conventions, review gates, and validation criteria.
Maintainer A workspace role that adds deleting projects, managing members and their project access, and managing workspaces to everything an Editor can do (labelled maintainer in the API). Maintainers see every project of the account.
Multi-Tenancy The architecture that keeps each account's projects, models, members and configuration apart through account-scoped access. Mock data comes from the shared, read-only pool.
Owner The person who created the account. The owner holds a Maintainer membership, manages billing and cannot be removed from the account.
Readonly A workspace role that sees projects, the model and the data preview and reads board notes (labelled readonly in the API).
Reporter A workspace role that adds board notes and comments to everything a Readonly member can do (labelled reporter in the API).
Review Gate A checkpoint where model, API, or export changes are validated before consumers rely on them — e.g., runtime validation before an export.
Tenant An account's boundary with its own members, projects, API keys, configuration, and plan limits. Mock data comes from the shared, read-only pool.
Tenant Team The members of your account and their workspace roles, managed under Account → Tenant → Tenant team. See Team & Roles.
Infrastructure & Deployment
Docker Containerization technology. A code package contains a Docker Compose file that starts MySQL and Redis for the generated backend, but no Dockerfile for the backend itself; add one for your target platform to run it in a container (see Export).