@skaterqiang/protege-js 0.1.0

package/scripts/verify-api.js

@@ -0,0 +1,53 @@
+'use strict';
+
+// ---------------------------------------------------------------------------
+// scripts/verify-api.js — smoke test for the public API entry point.
+//
+// Verifies that src/index.js exports every symbol the README documents, and
+// that the OWL 2 RL reasoner actually entails a trivial subsumption.
+// Run: node scripts/verify-api.js   (also used by CI)
+// ---------------------------------------------------------------------------
+
+const path = require('path');
+const p = require(path.join(__dirname, '..', 'src', 'index.js'));
+
+const need = [
+  // reasoners / inference
+  'OWL2RLReasoner', 'OWL2QLReasoner', 'OWL2ELReasoner', 'SWRLReasoner',
+  'TripleStore', 'ReasonerQueries',
+  // parsers
+  'TurtleParser', 'parseTurtle', 'parseRDFXML', 'FunctionalSyntaxParser',
+  'ManchesterSyntaxParser', 'OWLXMLParser', 'SWRLParser',
+  // writers
+  'writeTurtle', 'writeRDFXML', 'writeFunctionalSyntax',
+  // bridges / loader
+  'triplesToOntology', 'OntologyLoader',
+  // profiles / validation
+  'checkRL', 'checkQL', 'checkEL', 'checkProfile', 'isInProfile',
+  'GlobalRestrictionsValidator',
+  // model
+  'IRI', 'OWLLiteral', 'OWLOntology', 'OWLModelManager',
+  'OWLClass', 'OWLSubClassOfAxiom',
+  // namespaces
+  'model', 'io', 'inference', 'profiles'
+];
+
+const miss = need.filter((k) => !(k in p));
+if (miss.length) {
+  console.error('FAIL — missing exports:', miss.join(', '));
+  process.exit(1);
+}
+
+// Functional smoke: cax-sco + prp-type entailment through the flat API.
+const RDFS = 'http://www.w3.org/2000/01/rdf-schema#subClassOf';
+const RDF = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
+const r = new p.OWL2RLReasoner(new p.TripleStore());
+r.store.add('ex:A', RDFS, 'ex:B');
+r.store.add('ex:x', RDF, 'ex:A');
+r.materialize();
+if (!r.entails('ex:x', RDF, 'ex:B')) {
+  console.error('FAIL — RL reasoner did not entail ex:x rdf:type ex:B');
+  process.exit(1);
+}
+
+console.log(`OK — public API verified: ${Object.keys(p).length} exports, RL smoke entailment passed`);

package/src/index.js

@@ -0,0 +1,176 @@
+'use strict';
+
+// ---------------------------------------------------------------------------
+// protege-js — public API entry point.
+//
+// Everything is re-exported here so consumers can do:
+//
+//   const { OWL2RLReasoner, TurtleParser } = require('@skaterqiang/protege-js');
+//
+// Namespaced access is available too, for callers that prefer grouping:
+//
+//   const protege = require('@skaterqiang/protege-js');
+//   protege.inference.OWL2RLReasoner
+//   protege.io.TurtleParser
+//   protege.model.OWLClass
+//
+// Zero runtime dependencies. CommonJS. Node >= 18 (uses node:test in dev only).
+// ---------------------------------------------------------------------------
+
+// --- model -----------------------------------------------------------------
+const { IRI } = require('./model/IRI');
+const entity = require('./model/OWLEntity');
+const axiom = require('./model/OWLAxiom');
+const classExpr = require('./model/OWLClassExpression');
+const { OWLLiteral } = require('./model/OWLLiteral');
+const { OWLOntology, OWLOntologyID } = require('./model/OWLOntology');
+const { OWLModelManager } = require('./model/OWLModelManager');
+const swrlModel = require('./model/SWRL');
+const { EventType, OWLModelManagerChangeEvent } = require('./model/event/OWLModelManagerEvent');
+const hierarchy = require('./model/hierarchy/HierarchyProvider');
+
+// --- io --------------------------------------------------------------------
+const { TurtleParser, parseTurtle } = require('./io/TurtleParser');
+const { writeTurtle, TurtleWriter } = require('./io/TurtleWriter');
+const { parseRDFXML } = require('./io/RDFXMLParser');
+const { writeRDFXML, RDFXMLWriter } = require('./io/RDFXMLWriter');
+const { FunctionalSyntaxParser } = require('./io/FunctionalSyntaxParser');
+const funcWriter = require('./io/FunctionalSyntaxWriter');
+const { ManchesterSyntaxParser } = require('./io/ManchesterSyntaxParser');
+const { OWLXMLParser } = require('./io/OWLXMLParser');
+const { SWRLParser } = require('./io/SWRLParser');
+const { triplesToOntology } = require('./io/RDFGraphToOntology');
+const { OntologyLoader } = require('./io/OntologyLoader');
+
+// --- inference -------------------------------------------------------------
+const { TripleStore } = require('./inference/TripleStore');
+const rdf = require('./inference/rdf');
+const { OWL2RLReasoner } = require('./inference/OWL2RLReasoner');
+const { OWL2QLReasoner, OWL2ELReasoner, ProfileReasoner } = require('./inference/OWL2ProfileReasoners');
+const { SWRLReasoner, SWRLBuiltins } = require('./inference/SWRLReasoner');
+const { ReasonerQueries } = require('./inference/ReasonerQueries');
+const { rules: OWL2RL_RULES } = require('./inference/rules/owl2rl');
+const { QL_RULE_IDS } = require('./inference/rules/owl2ql');
+const { EL_RULE_IDS } = require('./inference/rules/owl2el');
+
+// --- profiles / validation -------------------------------------------------
+const profiles = require('./profiles/OWL2Profiles');
+const { GlobalRestrictionsValidator } = require('./validation/GlobalRestrictionsValidator');
+
+// ---------------------------------------------------------------------------
+// Namespaces
+// ---------------------------------------------------------------------------
+
+const model = Object.assign(
+  {
+    IRI,
+    OWLLiteral,
+    OWLOntology,
+    OWLOntologyID,
+    OWLModelManager,
+    EventType,
+    OWLModelManagerChangeEvent
+  },
+  entity,
+  axiom,
+  classExpr,
+  swrlModel,
+  hierarchy
+);
+
+const io = {
+  // parsers
+  TurtleParser,
+  parseTurtle,
+  parseRDFXML,
+  FunctionalSyntaxParser,
+  ManchesterSyntaxParser,
+  OWLXMLParser,
+  SWRLParser,
+  // writers
+  TurtleWriter,
+  writeTurtle,
+  RDFXMLWriter,
+  writeRDFXML,
+  writeFunctionalSyntax: funcWriter.writeFunctionalSyntax,
+  // bridges
+  triplesToOntology,
+  OntologyLoader
+};
+
+const inference = {
+  TripleStore,
+  OWL2RLReasoner,
+  OWL2QLReasoner,
+  OWL2ELReasoner,
+  ProfileReasoner,
+  SWRLReasoner,
+  SWRLBuiltins,
+  ReasonerQueries,
+  NS: rdf.NS,
+  P: rdf.P,
+  C: rdf.C,
+  isLiteral: rdf.isLiteral,
+  parseLiteral: rdf.parseLiteral,
+  literal: rdf.literal,
+  OWL2RL_RULES,
+  QL_RULE_IDS,
+  EL_RULE_IDS
+};
+
+// ---------------------------------------------------------------------------
+// Flat export surface (most common import style)
+// ---------------------------------------------------------------------------
+
+module.exports = Object.assign(
+  {
+    // namespaces
+    model,
+    io,
+    inference,
+    profiles,
+    // convenience: profile checks at top level
+    checkProfile: profiles.checkProfile,
+    isInProfile: profiles.isInProfile,
+    checkRL: profiles.checkRL,
+    checkQL: profiles.checkQL,
+    checkEL: profiles.checkEL,
+    Profiles: profiles.Profiles,
+    GlobalRestrictionsValidator,
+    // convenience: the classes people reach for first
+    IRI,
+    OWLLiteral,
+    OWLOntology,
+    OWLOntologyID,
+    OWLModelManager,
+    TripleStore,
+    OWL2RLReasoner,
+    OWL2QLReasoner,
+    OWL2ELReasoner,
+    SWRLReasoner,
+    ReasonerQueries,
+    TurtleParser,
+    parseTurtle,
+    parseRDFXML,
+    FunctionalSyntaxParser,
+    ManchesterSyntaxParser,
+    OWLXMLParser,
+    SWRLParser,
+    writeTurtle,
+    writeRDFXML,
+    writeFunctionalSyntax: funcWriter.writeFunctionalSyntax,
+    triplesToOntology,
+    OntologyLoader
+  },
+  // model layer (entities, axioms, class expressions, SWRL model, hierarchy)
+  entity,
+  axiom,
+  classExpr,
+  swrlModel,
+  hierarchy,
+  { EventType, OWLModelManagerChangeEvent },
+  // writers exported as classes too
+  { TurtleWriter, RDFXMLWriter },
+  // rdf namespace constants
+  { NS: rdf.NS, P: rdf.P, C: rdf.C }
+);

package/src/inference/OWL2ProfileReasoners.js

@@ -0,0 +1,67 @@
+'use strict';
+
+const { TripleStore } = require('./TripleStore');
+const { rules } = require('./rules/owl2rl');
+const { QL_RULE_IDS } = require('./rules/owl2ql');
+const { EL_RULE_IDS } = require('./rules/owl2el');
+
+// ---------------------------------------------------------------------------
+// OWL2QLReasoner / OWL2ELReasoner — profile-restricted forward chaining.
+// Each runs only the rule subset that is sound for its profile, reusing the
+// rule implementations from owl2rl.js. This is the "minimal inference" for
+// QL (query answering) and EL (classification) profiles.
+// ---------------------------------------------------------------------------
+
+class ProfileReasoner {
+  constructor(store, ruleIds) {
+    this.store = store || new TripleStore();
+    this.inconsistencies = [];
+    this._inferred = new Set();
+    this._rounds = 0;
+    this._ruleFns = ruleIds.map(id => [id, rules[id]]).filter(([, fn]) => typeof fn === 'function');
+  }
+
+  _add(s, p, o) {
+    const isNew = this.store.add(s, p, o);
+    if (isNew) this._inferred.add(TripleStore.key(String(s), String(p), String(o)));
+    return isNew;
+  }
+
+  _conflict(rule, message) {
+    if (!this.inconsistencies.some(c => c.rule === rule && c.message === message)) {
+      this.inconsistencies.push({ rule, message });
+    }
+  }
+
+  materialize(maxRounds = 1000) {
+    const add = (s, p, o) => this._add(s, p, o);
+    const conflict = (rule, msg) => this._conflict(rule, msg);
+    let round = 0, changed = true;
+    while (changed && round < maxRounds) {
+      round++;
+      const before = this.store.size();
+      for (const [id, fn] of this._ruleFns) {
+        fn(this.store, add, (msg) => conflict(id, msg));
+      }
+      changed = this.store.size() > before;
+    }
+    this._rounds = round;
+    return this._inferred.size;
+  }
+
+  isConsistent() { return this.inconsistencies.length === 0; }
+  getInferredCount() { return this._inferred.size; }
+  entails(s, p, o) { return this.store.has(s, p, o); }
+  getRounds() { return this._rounds; }
+  getRuleIds() { return this._ruleFns.map(([id]) => id); }
+}
+
+class OWL2QLReasoner extends ProfileReasoner {
+  constructor(store) { super(store, QL_RULE_IDS); }
+}
+
+class OWL2ELReasoner extends ProfileReasoner {
+  constructor(store) { super(store, EL_RULE_IDS); }
+}
+
+module.exports = { OWL2QLReasoner, OWL2ELReasoner, ProfileReasoner };

package/src/inference/OWL2RLReasoner.js

@@ -0,0 +1,65 @@
+'use strict';
+
+const { TripleStore } = require('./TripleStore');
+const { rules } = require('./rules/owl2rl');
+
+// ---------------------------------------------------------------------------
+// OWL2RLReasoner — forward-chaining materialization of the OWL 2 RL ruleset.
+// Runs all 78 rules to a fixpoint. Rules whose consequent is `false` record
+// an inconsistency instead of throwing.
+// ---------------------------------------------------------------------------
+
+class OWL2RLReasoner {
+  constructor(store) {
+    this.store = store || new TripleStore();
+    this.inconsistencies = [];   // [{rule, message}]
+    this._inferred = new Set();  // triples added during materialization
+    this._rounds = 0;
+  }
+
+  _add(s, p, o) {
+    const isNew = this.store.add(s, p, o);
+    if (isNew) this._inferred.add(TripleStore.key(String(s), String(p), String(o)));
+    return isNew;
+  }
+
+  _conflict(rule, message) {
+    // dedupe identical findings
+    if (!this.inconsistencies.some(c => c.rule === rule && c.message === message)) {
+      this.inconsistencies.push({ rule, message });
+    }
+  }
+
+  /** Run the ruleset to a fixpoint. Returns number of new triples derived. */
+  materialize(maxRounds = 1000) {
+    const add = (s, p, o) => this._add(s, p, o);
+    const conflict = (rule, msg) => this._conflict(rule, msg);
+    let round = 0;
+    let changed = true;
+    while (changed && round < maxRounds) {
+      round++;
+      const before = this.store.size();
+      for (const [id, fn] of Object.entries(rules)) {
+        fn(this.store, add, (msg) => conflict(id, msg));
+      }
+      changed = this.store.size() > before;
+      // conflicts don't add triples, so keep looping while they emerge? They are
+      // terminal; no need to loop for conflicts alone.
+    }
+    this._rounds = round;
+    return this._inferred.size;
+  }
+
+  /** True iff no inconsistency was recorded. */
+  isConsistent() { return this.inconsistencies.length === 0; }
+
+  /** Number of triples inferred (not present in the input). */
+  getInferredCount() { return this._inferred.size; }
+
+  /** True iff triple (s,p,o) holds in the materialized store. */
+  entails(s, p, o) { return this.store.has(s, p, o); }
+
+  getRounds() { return this._rounds; }
+}
+
+module.exports = { OWL2RLReasoner, TripleStore };

package/src/inference/ReasonerQueries.js

@@ -0,0 +1,111 @@
+'use strict';
+
+// ---------------------------------------------------------------------------
+// inference/ReasonerQueries — high-level query API over a materialized
+// OWL2RLReasoner. Mirrors the OWLReasoner query methods of the OWL API:
+// getSubClasses / getSuperClasses / getInstances / getTypes / isSubClassOf /
+// isSatisfiable / getEquivalentClasses.
+// ---------------------------------------------------------------------------
+
+const { NS } = require('./rdf');
+const RDF = NS.RDF, RDFS = NS.RDFS, OWL = NS.OWL;
+
+class ReasonerQueries {
+  /**
+   * @param {OWL2RLReasoner} reasoner  already materialized (call .materialize() first)
+   */
+  constructor(reasoner) {
+    this.reasoner = reasoner;
+    this.store = reasoner.store;
+  }
+
+  /** Direct + indirect subclasses of `clsIRI`. */
+  getSubClasses(clsIRI, { direct = false } = {}) {
+    const subs = this.store.subjects(RDFS + 'subClassOf', clsIRI);
+    if (direct) return subs;
+    return subs;
+  }
+
+  /** Direct + indirect superclasses of `clsIRI`. */
+  getSuperClasses(clsIRI, { direct = false } = {}) {
+    return this.store.objects(clsIRI, RDFS + 'subClassOf');
+  }
+
+  /** All instances (individuals) of `clsIRI`. */
+  getInstances(clsIRI) {
+    return this.store.subjects(RDF + 'type', clsIRI)
+      .filter(s => !String(s).startsWith('_:'));
+  }
+
+  /** All classes that `individualIRI` is an instance of. */
+  getTypes(individualIRI) {
+    return this.store.objects(individualIRI, RDF + 'type')
+      .filter(t => t !== OWL + 'NamedIndividual' && t !== OWL + 'Class'
+        && t !== OWL + 'ObjectProperty' && t !== OWL + 'DatatypeProperty'
+        && t !== OWL + 'AnnotationProperty');
+  }
+
+  /** True iff sub ⊑ super (asserted or inferred). */
+  isSubClassOf(subIRI, superIRI) {
+    return this.store.has(subIRI, RDFS + 'subClassOf', superIRI);
+  }
+
+  /** True iff sub ⊑ super along subPropertyOf. */
+  isSubPropertyOf(subIRI, superIRI) {
+    return this.store.has(subIRI, RDFS + 'subPropertyOf', superIRI);
+  }
+
+  /** Equivalent classes of clsIRI (owl:equivalentClass both directions). */
+  getEquivalentClasses(clsIRI) {
+    const fwd = this.store.objects(clsIRI, OWL + 'equivalentClass');
+    const bwd = this.store.subjects(OWL + 'equivalentClass', clsIRI);
+    return [...new Set([...fwd, ...bwd])];
+  }
+
+  /** Disjoint classes of clsIRI. */
+  getDisjointClasses(clsIRI) {
+    const fwd = this.store.objects(clsIRI, OWL + 'disjointWith');
+    const bwd = this.store.subjects(OWL + 'disjointWith', clsIRI);
+    return [...new Set([...fwd, ...bwd])];
+  }
+
+  /** Same individuals (owl:sameAs both directions). */
+  getSameIndividuals(indIRI) {
+    const fwd = this.store.objects(indIRI, OWL + 'sameAs');
+    const bwd = this.store.subjects(OWL + 'sameAs', indIRI);
+    return [...new Set([...fwd, ...bwd])];
+  }
+
+  /**
+   * A class is unsatisfiable iff it is subclass of owl:Nothing.
+   * True = satisfiable (no proof of emptiness under OWA).
+   */
+  isSatisfiable(clsIRI) {
+    return !this.store.has(clsIRI, RDFS + 'subClassOf', OWL + 'Nothing');
+  }
+
+  /** Object property values for an individual. */
+  getObjectPropertyValues(indIRI, propIRI) {
+    return this.store.objects(indIRI, propIRI);
+  }
+
+  /** Data property values for an individual. */
+  getDataPropertyValues(indIRI, propIRI) {
+    return this.store.objects(indIRI, propIRI);
+  }
+
+  /** Named roots: classes that are not a subclass of any named class except owl:Thing. */
+  getTopClasses() {
+    const allClasses = new Set();
+    for (const [s] of this.store.match(null, RDF + 'type', OWL + 'Class')) {
+      if (!String(s).startsWith('_:')) allClasses.add(s);
+    }
+    const hasSuper = new Set();
+    for (const [s, , o] of this.store.match(null, RDFS + 'subClassOf', null)) {
+      if (!String(o).startsWith('_:') && o !== OWL + 'Thing') hasSuper.add(s);
+    }
+    return [...allClasses].filter(c => !hasSuper.has(c));
+  }
+}
+
+module.exports = { ReasonerQueries };