RDF Vocabularies for Dart - Type-safe RDF Constants

What is RDF Vocabularies for Dart?

rdf_vocabularies provides a type-safe, ergonomic way to work with RDF vocabularies in Dart applications that use rdf_core. Instead of dealing with string literals for IRIs, this package offers compile-time constants organized in an intuitive class structure, making RDF development in Dart more productive and less error-prone.

📦

Zero Runtime Overhead

Nearly all content is composed of compile-time constants, resulting in no runtime performance penalty.

🔍

IDE Discovery

Explore vocabularies through IDE autocompletion - no more guessing which predicates you can use.

📝

Documentation Built-in

Each vocabulary term includes its original description, accessible right in your editor and through our extensive API Reference.

🔒

Type Safety

Catch vocabulary errors at compile time, not at runtime when it's too late.

🔄

Two Usage Patterns

Use class-specific terms for guided development or full vocabulary access for flexibility.

🌍

Comprehensive

Includes constants for the most widely used RDF vocabularies in the Semantic Web.

Getting Started

To use rdf_vocabularies in your Dart project, you'll need to add it to your dependencies in pubspec.yaml:

dependencies:
  rdf_vocabularies: ^0.3.0
  rdf_core: ^0.9.0  # Required for RDF data structures

Then run:

dart pub get

Import the vocabularies you need in your Dart files:

// For beginners using class-specific approach
import 'package:rdf_vocabularies/schema.dart';
import 'package:rdf_vocabularies/src/generated/schema/classes/person.dart';
import 'package:rdf_vocabularies/src/generated/schema/classes/postal_address.dart';

// For experts using full vocabulary approach
import 'package:rdf_vocabularies/schema.dart';
import 'package:rdf_vocabularies/rdf.dart';
import 'package:rdf_vocabularies/foaf.dart';

Two Usage Patterns

Class-Specific Approach

If you're new to RDF or prefer guided development, the class-specific approach provides:

Focused access to properties relevant for a specific resource type
Better discoverability through IDE autocompletion
Protection from using incompatible terms

Tip: When you import a class-specific file like SchemaPerson, your IDE will only show relevant properties for Person objects, making discovery easier.

Example: Creating a Person with Address

import 'package:rdf_core/rdf_core.dart';
import 'package:rdf_vocabularies/schema.dart';
import 'package:rdf_vocabularies/src/generated/schema/classes/person.dart';
import 'package:rdf_vocabularies/src/generated/schema/classes/postal_address.dart';
import 'package:rdf_vocabularies/xsd.dart';

void main() {
  final personIri = IriTerm('http://example.org/person/jane_doe');
  final addressNode = BlankNodeTerm();
  
  // Create a graph with triples using class-specific constants
  final graph = RdfGraph.fromTriples([
    // Declare the resource type
    Triple(personIri, SchemaPerson.rdfType, SchemaPerson.classIri),
    
    // Use properties specific to Person
    Triple(personIri, SchemaPerson.name, LiteralTerm.string('Jane Doe')),
    Triple(personIri, SchemaPerson.email, LiteralTerm.string('jane.doe@example.com')),
    Triple(personIri, SchemaPerson.birthDate, LiteralTerm('1990-01-01', datatype: Xsd.date)),

    // Even those defined in other vocabularies, if their relationship is known to the library
    Triple(personIri, SchemaPerson.foafAge, LiteralTerm.integer(42)),

    // For properties from foreign vocabularies that are not restricted to a specific class, 
    // but are designed to be used universally, you can use the generated UniversalProperties
    // classes. 
    Triple(personIri, DcUniversalProperties.creator, LiteralTerm.string('System')),


    // Create a complex structure with an address
    Triple(personIri, SchemaPerson.address, addressNode),
    Triple(addressNode, SchemaPostalAddress.rdfType, SchemaPostalAddress.classIri),
    Triple(addressNode, SchemaPostalAddress.streetAddress, LiteralTerm.string('123 Main St')),
    Triple(addressNode, SchemaPostalAddress.addressLocality, LiteralTerm.string('Anytown')),
    Triple(addressNode, SchemaPostalAddress.postalCode, LiteralTerm.string('12345')),
  ]);
  
  // Your IDE will help you discover valid properties for each class
}

Full Vocabulary Approach

For experienced RDF developers who know exactly which vocabulary terms they need, the full vocabulary approach provides:

Direct access to all terms in a vocabulary
Flexibility to mix terms from multiple vocabularies freely
More concise import patterns

Note: With this approach, it's up to you to know which predicates are appropriate for which types of resources. The library won't restrict your choices.

Example: Creating a Person with Multiple Vocabulary Terms

import 'package:rdf_core/rdf_core.dart';
import 'package:rdf_vocabularies/schema.dart';
import 'package:rdf_vocabularies/rdf.dart';
import 'package:rdf_vocabularies/foaf.dart';
import 'package:rdf_vocabularies/xsd.dart';

void main() {
  final personIri = IriTerm('http://example.org/person/jane_doe');
  final addressNode = BlankNodeTerm();
  
  // Create a graph with direct vocabulary access
  final graph = RdfGraph.fromTriples([
    Triple(personIri, Rdf.type, Schema.Person),
    
    // Mix properties from different vocabularies freely
    Triple(personIri, Schema.name, LiteralTerm.string('Jane Doe')),
    Triple(personIri, Foaf.age, LiteralTerm.integer(42)),
    Triple(personIri, Schema.email, LiteralTerm.string('jane.doe@example.com')),
    
    // Create a complex structure with an address
    Triple(personIri, Schema.address, addressNode),
    Triple(addressNode, Rdf.type, Schema.PostalAddress),
    Triple(addressNode, Schema.streetAddress, LiteralTerm.string('123 Main St')),
    Triple(addressNode, Schema.addressLocality, LiteralTerm.string('Anytown')),
    Triple(addressNode, Schema.postalCode, LiteralTerm.string('12345')),
  ]);
}

API Documentation

Our comprehensive API Documentation is a key resource for developers:

Complete Vocabulary Overview: Browse all available vocabularies and their structure
Term Descriptions: Access original definitions for each RDF term and property
Class Hierarchy: Understand relationships between vocabulary classes

Explore the API Documentation

Performance Impact

Including rdf_vocabularies in your project has minimal impact on performance and size:

Package Size: Minimal impact as it consists primarily of constants
Runtime Performance: Zero runtime overhead since values are compile-time constants
Memory Usage: Negligible increase in memory usage
Build Time: May slightly increase initial build time, but no impact on runtime performance

Supported Vocabularies

This package includes constants for many popular RDF vocabularies:

ACL: Web Access Control vocabulary
Contact: Contact information vocabulary
DC: Dublin Core basic elements
DCMIType: Dublin Core type vocabulary
DCTerms: Dublin Core terms
EventOwl: Event vocabulary
FOAF: Friend of a Friend vocabulary
GEO: Geospatial vocabulary
LDP: Linked Data Platform vocabulary
OWL: Web Ontology Language
RDF: Resource Description Framework base vocabulary
RDFS: RDF Schema vocabulary
Schema: Schema.org vocabulary
SKOS: Simple Knowledge Organization System
Solid: Solid platform vocabulary
VCard: vCard ontology for contacts
VS: Vocabulary Status ontology
XSD: XML Schema Datatypes

Advanced Use Cases

RDF Graph Queries

Using the vocabulary constants makes query patterns both safer and more readable:

// Find all schema:Person objects in a graph
final allPersons = graph.findTriples(
  predicate: Rdf.type,
  object: Schema.Person
).map((triple) => triple.subject);

// Query for all email addresses of a person
final emails = graph.findTriples(
  subject: personIri,
  predicate: Schema.email
).map((triple) => triple.object);

// Find a person by name
final janeNode = graph.findTriples(
  predicate: Schema.name,
  object: LiteralTerm.string('Jane Doe')
).map((triple) => triple.subject).firstOrNull;

Multi-Vocabulary Integration

The library excels at helping you integrate data from multiple sources:

// Create a person using both Schema.org and FOAF terms
graph.addAll([
  Triple(personIri, Rdf.type, Schema.Person),
  Triple(personIri, Schema.name, LiteralTerm.string('Jane Doe')),
  Triple(personIri, Foaf.mbox, IriTerm('mailto:jane.doe@example.com')),
  Triple(personIri, Foaf.knows, IriTerm('http://example.org/person/john_smith')),
  Triple(personIri, Dc.creator, LiteralTerm.string('System')),
]);

Contributing

Contributions, bug reports, and feature requests are welcome! Here's how you can contribute:

Fork the repository on GitHub
Create a branch for your changes (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add some amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a pull request

For more details, see the CONTRIBUTING.md file.