@graviola/edb-core-types

Core TypeScript type definitions for the Graviola framework.

Overview

This package provides essential TypeScript type definitions used throughout the Graviola framework. It defines the core data structures, interfaces, and types for working with RDF data, SPARQL queries, entity management, and application settings.

Ecosystem Integration

Position in the Graviola Framework

The core-types package is a foundational component of the Graviola framework, providing type definitions that are used across almost all other packages. It establishes a common type system for working with RDF data, SPARQL endpoints, entity definitions, and more. This package is essential for maintaining type safety and consistency throughout the framework.

Dependency Graph

flowchart TD
    A[graviola/edb-core-types] --> B[@rdfjs/types]
    A --> C[@rdfjs/namespace]
    D[graviola/sparql-schema] --> A
    E[graviola/core-utils] --> A
    F[graviola/state-hooks] --> A
    G[graviola/data-mapping] --> A
    H[graviola/prisma-db-impl] --> A
    I[graviola/sparql-db-impl] --> A
    J[graviola/remote-query] --> A
    K[graviola/entity-finder] --> A
    L[many other packages...] --> A

    style A fill:#f9f,stroke:#333,stroke-width:2px

Package Relationships

• Peer Dependencies:

  • @rdfjs/namespace: RDF/JS namespace builder
  • @rdfjs/types: RDF/JS type definitions

• Used By:

  • Most packages in the Graviola framework, including:
    • @graviola/sparql-schema: For SPARQL and RDF type definitions
    • @graviola/core-utils: For entity and data structure types
    • @graviola/state-hooks: For state management types
    • @graviola/data-mapping: For field mapping types
    • @graviola/prisma-db-impl: For database implementation types
    • @graviola/sparql-db-impl: For SPARQL database implementation types
    • @graviola/remote-query: For remote query types
    • And many more...

Installation

bun add @graviola/edb-core-types
# or
npm install @graviola/edb-core-types
# or
yarn add @graviola/edb-core-types

Features

RDF and SPARQL Types

• Prefixes: Type definitions for RDF prefixes and namespace builders
• SparqlEndpoint: Interface for SPARQL endpoint configuration
• SPARQLFlavour: Type for different SPARQL implementation flavors
• CRUDFunctions: Interface for CRUD operations on RDF data
• RDFSelectResult: Type for SPARQL SELECT query results
• QueryOptions: Type for SPARQL query options

Entity Types

• NamedEntityData: Interface for entities with an ID
• NamedAndTypedEntity: Interface for entities with an ID and type
• Entity: Comprehensive entity interface with label, description, and image
• BasicThingInformation: Simplified entity information for UI display

Field Extraction and Mapping

• FieldExtractDeclaration: Type for field extraction definitions
• PrimaryField: Interface for primary entity fields (label, description, image)
• PrimaryFieldExtract: Interface for extracting primary fields from entities
• PrimaryFieldResults: Interface for extraction results

Settings and Configuration

• Settings: Interface for application settings
• Features: Interface for feature flags
• SparqlEndpoint: Interface for SPARQL endpoint configuration
• OpenAIConfig: Interface for OpenAI integration settings
• GoogleDriveConfig: Interface for Google Drive integration settings
• ExternalAuthorityConfig: Interface for external authority configuration

Utility Types

• Permission: Interface for view/edit permissions
• PermissionDeclaration: Type for declaring permissions by entity type
• ColumnDesc: Type for column descriptions
• WalkerOptions: Options for graph traversal
• AutocompleteSuggestion: Type for autocomplete suggestions

Usage

Import types from this package in your TypeScript files:

import type {
  NamedAndTypedEntity,
  SparqlEndpoint,
  PrimaryField,
} from "@graviola/edb-core-types";

// Define a typed entity
const person: NamedAndTypedEntity = {
  "@id": "http://example.org/person/1",
  "@type": "http://example.org/ontology#Person",
  name: "John Doe",
  age: 30,
};

// Configure a SPARQL endpoint
const endpoint: SparqlEndpoint = {
  label: "Local Oxigraph",
  endpoint: "http://localhost:7878/query",
  active: true,
  provider: "oxigraph",
};

// Define primary fields for an entity type
const personFields: PrimaryField = {
  label: "name",
  description: "bio",
  image: "photo",
};

Settings Types

Import settings types for application configuration:

import type { Settings, Features } from "@graviola/edb-core-types/settings";

// Define application features
const features: Features = {
  enablePreview: true,
  enableDebug: false,
  enableBackdrop: true,
  enableStylizedCard: true,
};

// Define application settings
const settings: Settings = {
  lockedEndpoint: false,
  sparqlEndpoints: [
    {
      label: "Local Oxigraph",
      endpoint: "http://localhost:7878/query",
      active: true,
      provider: "oxigraph",
    },
  ],
  features,
  openai: {
    apiKey: process.env.OPENAI_API_KEY,
  },
  googleDrive: {},
  externalAuthority: {},
};

Internal Usage

This package is used throughout the Graviola framework to provide type definitions. Here's an example from the sparql-schema package:

// From packages/sparql-schema/src/crud/load.ts
import type {
  CRUDFunctions,
  NamedAndTypedEntity,
  SPARQLCRUDOptions,
} from "@graviola/edb-core-types";
import { JSONSchema7 } from "json-schema";

export async function load({
  entityIRI,
  typeIRI,
  schema,
  sparqlEndpoint,
  crudFunctions,
  options,
}: {
  entityIRI: string;
  typeIRI: string;
  schema: JSONSchema7;
  sparqlEndpoint: string;
  crudFunctions?: CRUDFunctions;
  options?: SPARQLCRUDOptions;
}): Promise<NamedAndTypedEntity> {
  // Implementation...
}

License

This package is part of the Graviola project.