DataModel Inspector

Runs inspections on a DataModel and returns a structured InspectionReport.

The inspector does not modify the model. It reports issues for callers to handle. Provide a DataFormatSchema to enable schema-specific checks; omit it to run only schema-agnostic checks.

Shape

classDiagram
    direction TB
    class inspectDataModel {
      +(params) InspectionReport
    }
    class InspectDataModelParams {
      +dataModel : DataModel
      +schema?   : DataFormatSchema
      +registry? : InspectionRegistry
      +checkX?   : boolean
    }
    class InspectionReport {
      +issues   : Issue[]
      +errors / warnings / info
      +byCode   : Map
    }
    class Issue {
      +code     : string
      +severity : error | warning | info
      +message  : string
      +resourceId? / context?
    }
    class Inspection {
      +codes   : string[]
      +schemas?: string[]
      +run(dataModel, push)
    }
    class InspectionRegistry
    class DataFormatSchema {
      +id                : string
      +objectTypes       : Map
      +relationshipTypes : Map
    }
    class DataModel {
      <<data>>
    }
    inspectDataModel ..> InspectDataModelParams : reads
    inspectDataModel ..> InspectionReport : returns
    InspectDataModelParams o-- DataModel
    InspectDataModelParams o-- DataFormatSchema
    InspectDataModelParams o-- InspectionRegistry
    InspectionRegistry "1" *-- "*" Inspection
    InspectionReport "1" *-- "*" Issue
    Inspection ..> DataFormatSchema : optional schemas[]

Pipeline

flowchart LR
    A[DataModel] --> B[inspectDataModel]
    C[DataFormatSchema] --> B
    B --> D[InspectionReport]
    D -. errors .-> E[caller handles report]

Installation

npm install @xeokit/sdk
Copy

Core Types

• Issue: one finding with severity, code, message, optional resource id, and optional context.
• InspectionReport: issue list plus severity and code groupings.
• Inspection: {codes[], description, run}. Walks a DataModel and returns issues.

DataFormatSchema

A DataFormatSchema lists allowed object types, allowed relationship types, inheritance chains, and required or forbidden property sets. Pass one via InspectDataModelParams.schema.

const schema: DataFormatSchema = {
  id: "MyApp/v1",
  objectTypes: {
    Building: {label: "Building"},
    Floor:    {superType: "Building"},
    Door:     {superType: "Floor", requiredPropertySets: ["DoorMetadata"]},
  },
  relationshipTypes: {
    contains: {
      allowedRelatingTypes: ["Building", "Floor"],
      allowedRelatedTypes:  ["Floor", "Door"],
    },
  },
};

const report = inspectDataModel({dataModel, schema});
if (report.errors.length > 0) { ... }
Copy

Registries

Inspections are stored in an InspectionRegistry. DEFAULT_INSPECTION_REGISTRY contains the built-in inspections. Plugins can register more inspections:

import {DEFAULT_INSPECTION_REGISTRY} from "@xeokit/sdk/inspect/dataModel";

DEFAULT_INSPECTION_REGISTRY.register({
  codes: ["MyApp/CHECK_NAMING"],
  description: "Enforce DataObject-naming convention",
  run(dataModel) { ... },
});
Copy

Tests and one-off pipelines can create a fresh InspectionRegistry and pass it with InspectDataModelParams.registry.

Built-in inspections

Schema Selection

Each Inspection can declare a list of schema ids. The inspector resolves the model's schema id from params.schema?.id ?? dataModel.schema and skips inspections whose schemas list does not include it.

IFC inspections run only for IFC4 / IFC4x3 / IFC4X3 / IFC4x1 / IFC4X1 / IFC4_ADD2_TC1 / IFC2x3 / IFC2X3. Inspections without schemas run for any model. A model with no schema id runs only schema-agnostic inspections.

Dangling-reference checks (RELATIONSHIP_DANGLING_*, OBJECT_DANGLING_PROPERTY_SET_REF) aren't included because DataModel builder methods reject unknown ids at construction time, so a live DataModel can't carry dangling endpoints.