API Serialisation Profiles
Configure how model entities are serialised for each API type (REST, GraphQL, gRPC, AsyncAPI, Webhooks, MCP) with naming conventions, date-time formats, enum transformations, and per-field overrides. One model property, multiple serialised representations, all controlled from profiles without modifying the model.
The gap between an architectural model and an API contract is wider than it appears. A model entity might define a property called created_date with a datetime type, but the public REST API needs it as createdDate in ISO 8601 format, the GraphQL schema needs it as createdDate with a custom DateTime scalar, and the internal gRPC service expects created_date as a google.protobuf.Timestamp. Enum values in the model might be stored as integers, but the API should expose them as human-readable strings. Different consumers, different protocols, and different conventions all need different representations of the same underlying data.
API serialisation profiles bridge this gap by defining how model entities are transformed for each API output, without modifying the model itself. NeoArc Studio supports all major API types, and each can have its own serialisation profile.
Profile Configuration
Each serialisation profile defines a set of conventions that control how model properties are transformed when generating API schemas.
| Setting | Options | Example |
|---|---|---|
| Naming Convention | camelCase / snake_case / PascalCase / kebab-case | userName vs user_name |
| DateTime Format | ISO 8601 / Unix timestamp / Custom | 2026-02-23T00:00:00Z vs 1772006400 |
| Enum Style | string / integer / PascalCase string | "active" vs 0 vs "Active" |
| Null Handling | include / omit / default value | null vs field omitted |
One Property, Six Serialisations
The real power of serialisation profiles is visible when a single model property is projected across multiple API types. Each API target applies its profile rules independently.
| API Type | Property Name | Type | Format |
|---|---|---|---|
| Model (source) | created_date | datetime | Abstract type, no format |
| REST API | createdDate | string | ISO 8601 (2026-02-23T00:00:00Z) |
| GraphQL | createdDate | DateTime (scalar) | ISO 8601 via custom scalar |
| gRPC | created_date | google.protobuf.Timestamp | Protobuf well-known type |
| AsyncAPI | createdDate | string | ISO 8601 in event payload |
| Webhooks | created_date | string | Unix timestamp (consumer preference) |
| MCP | createdDate | string | ISO 8601 in tool parameter schema |
How Profiles Work
Per-Field Overrides
While profiles define conventions at the global level, individual properties sometimes need exceptions. The per-field override system allows fine-grained control without abandoning the profile entirely.
The central model file is the single source of truth for every entity, relationship, and property in a NeoArc project. Abstract database-agnostic types, key roles, per-property projections for persistence, search, and API, governance classifications (PII, confidential, retention policies), shared property sets with live inheritance, comprehensive validation rules, and import/export across a wide range of formats.
Every model property carries three independent projection configurations: persistence (how it is stored), search (how it is indexed), and API (how it is exposed). Each domain sees the same property through its own lens, controlled by profiles, without duplicating the definition.
Database profiles map abstract model types to vendor-specific concrete types with parameterised templates, naming conventions, and fidelity loss detection. Design your model once and generate correct DDL for any database vendor, with built-in vendor templates covering SQL Server, PostgreSQL, MySQL, Oracle, MongoDB, SQLite, Snowflake, MariaDB, CockroachDB, Azure Table Storage, Azure Cosmos DB, Amazon DynamoDB, and Apache Cassandra.
Search profiles configure how model entities project into search indexes across supported engines including Elasticsearch, Azure Cognitive Search, OpenSearch, Typesense, Algolia, and custom engines. Includes operational strategies, index lifecycle management, and search drift detection.