Schema and Extensions

Overview

The schema defines what a project's model can hold: the classes of entities, the attributes each class has, the relations that may connect classes, the labels that tag entities, and optional workflows that limit how a status attribute may change.

Every project starts from the default Lifecycle Modeling Language (LML) schema. The Schema Editor changes it for one project only: the first edit creates the project's own copy, so other projects are unaffected. Every schema edit is one undo step.

Holarch also adds a set of built-in extensions to every project, such as Priority and Owner on requirements and Handling Strategy on risks. They are listed in Built-in extensions.

For working with entities, attributes and relationships day to day, see Model and Database.

Concepts

The project schema

• Default schema: the LML classes, relations, attributes and labels Holarch ships with. The in-app Help topics LML Classes (schema), LML Relationships (schema) and Labels (schema) list them live for the open project.
• Project schema: a copy stored inside the project. It is created on the first edit and travels with the project in exports and to every member who opens it.
• Built-in extensions: additions that Holarch's features need. They are applied by name each time a project opens, so most projects already have their own copy and the Schema Summary reads "This project has its own (edited) schema."

Classes

A class has a Name, Description, Parent, Color, and two flags:

• Parent: a subclass inherits its parent's attributes and relation targets, and appears in every query, filter and diagram that covers the parent. A custom subclass of Action gets action diagrams; a custom subclass of Requirement gets the quality checks and approval controls.
• Abstract: the class groups subclasses and cannot be created directly.
• Hidden: the class is not offered when creating or transforming entities and is left out of the Database class filter (with its subclasses). Existing entities stay.
• Color: the class badge and swatch color. Without one, a custom class takes the color of its nearest built-in ancestor. The badge shows the first two letters of the name.

Attributes

An attribute belongs to a class (or to a relation) and has a Name, Type, Order, optional Choices, an optional Default Value and a Description (shown when you hover the attribute's label). Types:

The editors for each type are described in Attribute types and editors.

Attributes inherited from parent classes are listed first, then the class's own attributes, each group by Order. A hidden attribute keeps its values but disappears from editors, filters, columns, searches and reports until it is shown again.

Relations and targets

• A relation is always a pair: a name and an inverse name, such as satisfies / satisfied by. Creating one creates both.
• A target allows a relation from one class to another, for example Requirement verified by Test Case. A target to a class also allows its subclasses. Subclasses inherit their parent's targets.
• Relations can carry attributes (for example Multiplicity on decomposed by). An attribute added to a relation also applies to its inverse.
• A hidden relation is shown dimmed in the Schema Editor and left out of the Help reference list; it stays usable.

Labels

A label has a Name, Description, optional Parent label (labels nest) and the Class(es) it applies to. With no class selected, the label applies to every class; a label for a class also applies to its subclasses. A hidden label stays on entities that have it but is no longer offered.

Workflows

A workflow watches one ENUMERATION attribute of a class (typically Status) and lists the allowed transitions (From → To). The attribute's editor then offers only the current value and the allowed next values.

How to use it

When and why

Tailor the schema at the start of a project, when you set up the modeling method, and before you import data:

• Adopt a method or standard: add the attributes your process requires (for example a TRL on assets, a Safety Integrity Level on requirements) and the labels your document templates expect.
• Specialize classes: add subclasses such as Hazard under Risk or Payload Instrument under Asset so queries, filters and reports can tell them apart while they keep every LML relationship.
• Allow a relationship the method needs: add a target, or a new relation pair.
• Enforce a review process: add a workflow so a requirement's Status moves Draft → In Review → Approved and never jumps steps in the editor.
• Reuse across projects: export the schema from one project and import it into the next.

The schema answers the question "What can this model say?". Change it deliberately: classes, attributes and relations are referenced by queries, saved columns, reports and imports.

Add an attribute to a class

1. Open Settings → Schema in the navigation rail.
2. In the sidebar under Classes, click the class (for example Asset).
3. In the Attributes card, click + Add New Attribute.
4. Enter the Name, choose the Type and keep or change the Order.
5. For ENUMERATION or MULTISELECT, type each choice in Choices and press Enter after each. Click × on a choice to remove it.
6. Optionally set a Default Value (new entities of the class start with it) and a Description.
7. Click Add Attribute. The toast "Attribute saved" confirms it. The attribute now appears in the inspector, the Entity View, Database columns and filters, searches, reports and import mappings for that class and its subclasses.

Add choices to an existing attribute

1. Open the class that defines the attribute (the Defined On column shows it; inherited attributes are edited on their own class).
2. Click ✎ (Edit Attribute) on the row.
3. Type the new choice in Choices and press Enter, then click Save.

Removing a choice does not change entities that already have that value, but the editor no longer offers it. Search for such entities with an attribute query (for example Requirement:"Priority=Urgent") and set a current choice before you remove the old one.

Create a subclass

1. Open the parent class and click + Subclass, or click + Class in the sidebar and choose the Parent.
2. Enter the Name and Description; set Abstract, Hidden and Color as needed.
3. Click Create Class. The new class opens. It already has every inherited attribute and target.
4. To move existing entities into it, select them in the Database and use Transform… (see Transform).

Add a label

1. Click + Label in the sidebar (or + New Label on the Labels page).
2. Enter the Name and Description, choose a Parent if it belongs under another label, and select the Class(es) it applies to (⌘/Ctrl+click for several; none selected means every class).
3. Click Create Label. Apply it from the inspector's Metadata tab, the Entity View's + Label, or Label ▾ in the Database bulk bar.

Allow a new relationship

1. Open the source class and click + Add New Target in Target Relations.
2. Choose the Relation and the Target Class. Keep Also add the inverse target on the target class checked so the link can be made from either end.
3. If the relation does not exist, click + New Relation, enter Name, Inverse Name and descriptions, and click Create Relation; then choose it.
4. Click Add Target.

Define a status workflow

1. Open Workflow in the sidebar.
2. In Add Workflow Class…, choose the class. Holarch watches its first enumeration attribute; change it in the watches list if needed (changing it clears the transitions).
3. Click + Add Transition for each allowed step. Set Name, From ((Initial — no value) or a choice) and To.
4. The editors now offer only the allowed next values, marked ⇢ workflow.

Share a schema between projects

1. In the source project, open Settings → Schema and click Export Schema. A JSON file downloads.
2. In the target project, click Import Schema… and choose the file.
3. Choose the Mode: Merge (add classes, attributes, relations and labels that are missing by name) or Replace this project's schema, and click Import.

Worked example: CubeSat EO-1

Create the demo with Manage Projects → Project Files ▾ → Create Demo Project and open Settings → Schema.

1. Look at the model. The Overview Dashboard shows Entity Class Summary (Asset, Requirement and Action have the most entities) and Labels by Entity Count.
2. Add a TRL to assets. Click Asset, then + Add New Attribute. Name TRL, Type ENUMERATION, choices 1 to 9, Description Technology readiness level. Click Add Attribute.
3. Fill it in. Open Architecture → Assets, select 1.2.1 Reaction Wheel Assembly and set TRL to 7 in the inspector; set 1.2.2 Star Tracker to 6 and 1.1 Payload Camera to 5.
4. Query it. In the search box type Asset:"TRL>=6" and press Enter. The query moves into the sidebar as an attribute filter chip and the table lists the reaction wheels and the star tracker. Choice values that are numbers compare as numbers.
5. Specialize a class. Back in the Schema Editor, open Asset, click + Subclass, name it Payload Instrument, and click Create Class. In the Database, check 1.1 Payload Camera, click Transform…, choose Payload Instrument. The dialog says "Nothing else changes." because the subclass inherits every Asset attribute and target. Click Transform. The camera keeps its TRL, its performs links and its place in the decomposition.
6. Add a review workflow. Open Workflow, choose Requirement in Add Workflow Class…, confirm it watches Status, and add transitions: Initial → Draft, Draft → In Review, In Review → Approved, In Review → Rejected, Rejected → Draft. Open 2.4 Target Slew (Status Draft): its Status list now offers only Draft and In Review.
7. Undo the experiment. Press ⌘Z once per step, or keep the changes and click Export Schema to reuse them in the next CubeSat project.

Tips and good practice

• Prefer subclasses and labels to new top-level classes. A subclass keeps every LML relation, diagram and check of its parent. A label changes nothing structural at all.
• Hide instead of delete. Hiding a class, attribute or label keeps existing data intact and can be reversed.
• Set up the schema before importing. The import mapping offers the attributes that exist; columns mapped to New Attribute are created automatically, with a guessed type (see Import and Export).
• Keep built-in additions. Hide a built-in extension you do not need rather than renaming or deleting it: a missing one is added again, with an empty value, the next time the project opens.
• Document every custom element in its Description; it appears as the tooltip in editors and in Help's schema tables.
• Less-than attribute tests also match entities with no value (Asset:"TRL<6" includes assets without a TRL). Combine them with a positive test, or use >= on the complement.

Common mistakes

• Changing an attribute's type clears its values. Holarch warns "N entities have a "X" value. Changing the type from A to B clears those values." Export a CSV report first if you need the old values.
• Deleting a relation deletes its relationships. The confirmation counts them. Undo restores them.
• Removing a target leaves invalid relationships. Existing links stay but are flagged by Model Checks. Remove or re-type them.
• A class cannot be deleted while it has entities. Transform or delete them first, or hide the class.
• Workflows only guide the editor. Bulk Attributes…, imports, the requirement Approve/Reject… controls and AI changes set the value directly.

How it connects to other features

• Database, inspector and Entity View show and edit the attributes and offer the relations the schema allows. Queries refer to classes, attributes, labels and relations by name. See Model and Database.
• Diagrams decide which diagram types an entity can have from its class lineage; custom subclasses inherit them.
• Requirements features (quality, approvals, TBD/TBR, suspect links) rely on built-in attributes such as Status, TBD/TBR and the quality criteria. See Requirements.
• Traceability Matrix and Model Checks use the relation targets to decide what is allowed and what is missing. See Traceability.
• Import and export map to attributes by name and carry the schema in project JSON, .inno and ReqIF files. See Import and Export.

The Schema Editor

Open it from Settings → Schema in the navigation rail. The address schema?class=<id> opens a class directly.

Top bar

Sidebar

• Search for a class, attribute, relation… filters the class tree and shows matching Classes, Attributes, Matching Relations and Matching Labels in the main area ("Nothing in the schema matches." when none).
• Overview Dashboard.
• + Class, + Label, + Relation.
• Classes: the class tree with color swatches, "(abstract)" and "(hidden)" marks, and the number of entities (including subclasses).
• Other: Relations (with the count), Labels (with the count) and Workflow.

Overview Dashboard

Schema Summary with a status line ("Default LML schema (edits create a project copy)." or "This project has its own (edited) schema.") and three cards:

• Entity Class Summary: a bar per class with its entity count. Click a bar to open the class.
• Labels by Entity Count: the 15 most used labels.
• Schema: the number of Classes, Relations, Attributes and Labels.

Class page

• Breadcrumb of parent classes (click to open one).
• Header: class icon and name, Abstract and Hidden chips, ✎ Edit Class, + Subclass, Delete, and N entities in project › (opens the Database filtered to the class).
• Description card: the description, "Identifier N · Total Properties N · Total Targeted Relations N", and the Subclasses.
• Attributes card with + Add New Attribute and a table: Order, Name, Type, Details (choices and default), Defined On ("this class" or the ancestor class), Description, and actions for attributes defined on this class: ✎ (Edit Attribute), ⊘ / 👁 (Hide Attribute / Show Attribute), × (Remove Attribute).
• Target Relations card with + Add New Target and a table: Relation, Target Classes (× removes a target defined on this class; inherited ones show "(inherited from X)"), Inverse and Description.
• Labels card: labels available on the class; * marks labels available on every class.

Edit Class dialog

Create New Class or Edit Class — X: Name, Description, Parent ((none — top level) or a class), Hidden, Abstract and Color. A built-in class that has entities cannot change its parent ("This built-in class has entities, so its parent cannot change."). Click Create Class or Save Class.

Attribute dialog

Add New Attribute or Edit Attribute — X (with "(relation "…")" for relation attributes): Name, Type, Order, Choices (ENUMERATION and MULTISELECT: "Press enter to add this option"), Default Value (not for FILE, COMPUTABLE, QUALITY, HTML and USER_TEAM) and Description. Click Add Attribute or Save.

Relations page

+ New Relation and a table: Relation, Inverse, Source → Target (every class pair allowed), Attributes (✎ per attribute and + Attribute), Used (number of relationships), Description, and ✎ (Edit Relation) / × (Delete Relation).

The relation dialog (New Relation or Edit Relation — X) has Name, Inverse Name, Description, Inverse Description and Hidden. When editing, it lists the relation's attributes with + Add Attribute. Click Create Relation or Save.

Labels page

+ New Label and a table in tree order: Label, Applies To (class chips or "All classes"), Entities (count), Description, and actions ✎ (Edit Label), ⊖ (Remove this label from all entities, shown when it is in use) and × (Delete Label).

The label dialog (Create New Label or Edit Label — X) has Name, Description, Parent ((none) or a label), Class(es) — none selected = every class and Hidden. Click Create Label or Save Label.

Workflow page

"Limit an enumeration attribute (e.g. Status) to defined transitions." Add Workflow Class… lists the classes that have an enumeration attribute and no workflow yet. Each workflow class has a card:

• The class chip, watches and the watched attribute.
• + Add Transition (adds "New Transition" from (Initial — no value) to the first choice) and Remove (removes the class's workflow).
• A table: Name, From, To, Lock and × to delete the transition.

How schema changes affect existing data

Every change is one undo step, and ⌘Z restores the schema together with any data it removed.

Built-in extensions

Holarch adds these elements to every project when it opens. They are matched by name (case-insensitive), only added when missing, and never renamed or removed; your edits to them are kept.

Labels added: Stakeholder Need and Interface Requirement (Requirement), Interface Block (Asset, under Block), Trade Study and Whiteboard (Artifact), Criteria and TPM (Measure).

Relation targets added: Decision alternative Asset, Action, Artifact, Resource, Statement and Requirement, with the inverse alternative of.

Framework pages (DoDAF and UAF) create the labels their products use the first time you add such a product.

Keyboard shortcuts

Options and settings

• The project schema is stored in the project and shared with every member who can open it. Members with the viewer role cannot change it ("View only: ask an owner for edit access.").
• Export Schema files use the holarch-schema format and contain the classes, relations, attributes, labels and workflow.

Messages

Confirmations state the consequence before a destructive change: Remove Attribute ("N entities have a value that will be cleared."), Change Attribute Type, Delete Class, Remove Target ("N existing relationship(s) stay but become invalid (the Intelligence view flags them)."), Delete Relation ("N relationship(s) using it are removed too."), Delete Label ("It is removed from N entities."), Remove Label From Entities and Reset Schema ("Custom classes, attributes, relations and labels are removed from the schema (entity data stays; Undo is available).").

Limits

• Class and label names: 100 characters. Attributes created by imports: 80 characters.
• The Lock option on a workflow transition is stored but does not yet lock the entity automatically. Lock approved entities by hand (see Locks).
• Workflows are applied only by the attribute editors in the inspector and Entity View.
• Merge does not add new choices to an attribute that already exists; add them in the attribute dialog.
• Reset to Default appears after the page is opened again once the schema has become custom.

Related

• Model and Database: entities, attribute editors, queries and bulk edits.
• Requirements: the requirement attributes, quality checks and approvals.
• Traceability: how relations feed the matrix and coverage checks.
• Import and Export: attribute mapping and schema in exchange files.
• Help: Schema, LML Primer.