eyeling 1.28.9 → 1.29.1

package/lib/engine.js

@@ -97,6 +97,7 @@ const {
   getDataFactory,
   internalTripleToRdfJsQuads,
   normalizeParsedReasonerInputSync,
+  normalizeParsedReasonerInputAsync,
   normalizeReasonerInputSync,
   normalizeReasonerInputAsync,
 } = require('./rdfjs');
@@ -105,6 +106,7 @@ const trace = require('./trace');
 const { deterministicSkolemIdFromKey } = require('./skolem');
 
 const deref = require('./deref');
+const { createFactStore, collectStore, MemoryFactStore, PersistentFactStore, tripleToStoreKey } = require('./store');
 
 const hasOwn = Object.prototype.hasOwnProperty;
 
@@ -3783,6 +3785,278 @@ function reasonStream(input, opts = {}) {
   return __out;
 }
 
+
+async function __parseRunAsyncInput(input, opts) {
+  const {
+    baseIri = null,
+    proof = false,
+    rdf = false,
+    sourceLabel = '<input>',
+  } = opts || {};
+
+  const parsedSourceList = parseN3SourceList(input, { baseIri, rdf: !!rdf, sourceLocations: !!proof });
+  if (parsedSourceList) return parsedSourceList;
+
+  const parsedObject = await normalizeParsedReasonerInputAsync(input);
+  if (parsedObject) {
+    if (baseIri && parsedObject.prefixes && typeof parsedObject.prefixes.setBase === 'function') parsedObject.prefixes.setBase(baseIri);
+    return parsedObject;
+  }
+
+  const n3Text = await normalizeReasonerInputAsync(input);
+  return parseN3Text(n3Text, {
+    baseIri: baseIri || '',
+    label: sourceLabel || '<input>',
+    keepSourceArtifacts: false,
+    sourceLocations: !!proof,
+    rdf: !!rdf,
+  });
+}
+
+function __storePatternTerm(t, subst) {
+  const applied = applySubstTerm(t, subst || __emptySubst());
+  return containsVarTerm(applied) ? null : applied;
+}
+
+function __mergeStoreSubst(base, delta) {
+  let out = base;
+  for (const k of Object.keys(delta || {})) {
+    const v = delta[k];
+    if (Object.prototype.hasOwnProperty.call(out, k)) {
+      if (!termsEqual(out[k], v)) return null;
+    } else {
+      if (out === base) out = __cloneSubst(base);
+      out[k] = v;
+    }
+  }
+  return out;
+}
+
+async function __proveGoalsAgainstStore(goals, subst, store, backRules, localFacts, depth, varGen, opts = {}) {
+  if (!Array.isArray(goals) || goals.length === 0) return [subst || __emptySubst()];
+  if (depth > 64) return [];
+
+  const goal0 = applySubstTriple(goals[0], subst || __emptySubst());
+  const rest = goals.slice(1);
+  const out = [];
+
+  if (isBuiltinPred(goal0.p)) {
+    const deltas = evalBuiltin(goal0, __emptySubst(), localFacts || [], backRules || [], depth, varGen, undefined);
+    for (const delta of deltas) {
+      const nextSubst = __mergeStoreSubst(subst || __emptySubst(), delta);
+      if (nextSubst === null) continue;
+      out.push(...await __proveGoalsAgainstStore(rest, nextSubst, store, backRules, localFacts, depth + 1, varGen, opts));
+      if (opts.maxResults && out.length >= opts.maxResults) return out.slice(0, opts.maxResults);
+    }
+    return out;
+  }
+
+  // Backward rules are kept in memory; they may call back into the persistent
+  // fact store for their own premises.
+  if (goal0.p instanceof Iri && Array.isArray(backRules) && backRules.length) {
+    ensureBackRuleIndexes(backRules);
+    const candRules = (backRules.__byHeadPred.get(goal0.p.__tid) || []).concat(backRules.__wildHeadPred || []);
+    for (const r of candRules) {
+      if (!r || !Array.isArray(r.conclusion) || r.conclusion.length !== 1) continue;
+      const rStd = standardizeRule(r, varGen);
+      const head = rStd.conclusion[0];
+      const s2 = unifyTriple(head, goal0, subst || __emptySubst());
+      if (s2 === null) continue;
+      const newGoals = (rStd.premise || []).concat(rest);
+      out.push(...await __proveGoalsAgainstStore(newGoals, s2, store, backRules, localFacts, depth + 1, varGen, opts));
+      if (opts.maxResults && out.length >= opts.maxResults) return out.slice(0, opts.maxResults);
+    }
+  }
+
+  const sPat = __storePatternTerm(goal0.s, subst || __emptySubst());
+  const pPat = __storePatternTerm(goal0.p, subst || __emptySubst());
+  const oPat = __storePatternTerm(goal0.o, subst || __emptySubst());
+
+  for await (const fact of store.match(sPat, pPat, oPat)) {
+    const s2 = unifyTriple(goal0, fact, subst || __emptySubst());
+    if (s2 === null) continue;
+    out.push(...await __proveGoalsAgainstStore(rest, s2, store, backRules, localFacts, depth + 1, varGen, opts));
+    if (opts.maxResults && out.length >= opts.maxResults) return out.slice(0, opts.maxResults);
+  }
+
+  return out;
+}
+
+async function runStoreBacked(input, store, opts = {}) {
+  const parsed = parseN3SourceList(input, {
+    baseIri: opts.baseIri || null,
+    rdf: !!opts.rdf,
+    sourceLocations: !!opts.proof,
+  }) || input;
+
+  const prefixes = parsed.prefixes;
+  const triples = parsed.triples || [];
+  const frules = parsed.frules || [];
+  const brules = parsed.brules || [];
+  const qrules = parsed.logQueryRules || [];
+
+  materializeRdfLists(triples, frules.concat(qrules || []), brules);
+  await store.batchAdd(triples, 'explicit');
+
+  const derived = [];
+  const derivedKeys = new Set();
+  const varGen = [0];
+  const maxIterations = Number.isInteger(opts.maxIterations) && opts.maxIterations > 0 ? opts.maxIterations : 1024;
+
+  for (let iteration = 0; iteration < maxIterations; iteration += 1) {
+    let changed = false;
+    for (let ruleIndex = 0; ruleIndex < frules.length; ruleIndex += 1) {
+      const r = frules[ruleIndex];
+      if (!r || r.isFuse || r.__dynamicConclusionTerm) continue;
+      __prepareForwardRule(r);
+      const solutions = await __proveGoalsAgainstStore(r.premise || [], __emptySubst(), store, brules, triples, 0, varGen, {});
+      for (const subst of solutions) {
+        for (const cpat of r.conclusion || []) {
+          const fact = applySubstTriple(cpat, subst);
+          if (!isGroundTriple(fact)) continue;
+          if (await store.add(fact, 'inferred')) {
+            const df = makeDerivedRecord(fact, r, (r.premise || []).map((p) => applySubstTriple(p, subst)), subst, false);
+            const key = tripleToStoreKey(fact);
+            if (!derivedKeys.has(key)) {
+              derivedKeys.add(key);
+              derived.push(df);
+            }
+            changed = true;
+          }
+        }
+      }
+    }
+    if (!changed) break;
+  }
+
+  let queryTriples = [];
+  const queryDerived = [];
+  if (qrules.length) {
+    for (const r of qrules) {
+      const solutions = await __proveGoalsAgainstStore(r.premise || [], __emptySubst(), store, brules, triples, 0, varGen, {});
+      for (const subst of solutions) {
+        for (const cpat of r.conclusion || []) {
+          const fact = applySubstTriple(cpat, subst);
+          if (!isGroundTriple(fact)) continue;
+          queryTriples.push(fact);
+          queryDerived.push(makeDerivedRecord(fact, r, (r.premise || []).map((p) => applySubstTriple(p, subst)), subst, false));
+        }
+      }
+    }
+  }
+
+  if (queryTriples.length) {
+    const seen = new Set();
+    queryTriples = queryTriples.filter((tr) => {
+      const key = tripleToStoreKey(tr);
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+  }
+
+  return {
+    prefixes,
+    facts: [],
+    derived,
+    queryMode: !!qrules.length,
+    queryTriples,
+    queryDerived,
+    closureN3: qrules.length
+      ? prettyPrintQueryTriples(queryTriples, prefixes)
+      : derived.map((df) => (opts.rdf ? tripleToRdfCompatible(df.fact, prefixes) : tripleToN3(df.fact, prefixes))).join('\n'),
+    store,
+    storeBacked: true,
+  };
+}
+
+
+function __withoutStoreOptions(opts) {
+  const out = { ...(opts || {}) };
+  delete out.store;
+  delete out.storePath;
+  delete out.storeClear;
+  return out;
+}
+
+function __normalizeStoreOption(opts) {
+  const cfg = opts && opts.store;
+  if (!cfg) return null;
+  if (typeof cfg === 'string') return { name: cfg, path: opts.storePath || undefined, clear: !!opts.storeClear };
+  if (typeof cfg === 'object') {
+    return {
+      ...cfg,
+      path: cfg.path || opts.storePath || undefined,
+      clear: !!(cfg.clear || opts.storeClear),
+    };
+  }
+  throw new TypeError('runAsync option "store" must be a store name string or a store options object');
+}
+
+async function runAsync(input, opts = {}) {
+  const storeConfig = __normalizeStoreOption(opts);
+  const runOpts = __withoutStoreOptions(opts);
+
+  // No store configured: keep ordinary in-memory behavior, but accept async RDF/JS
+  // iterables by normalizing the input before calling the synchronous engine.
+  if (!storeConfig) {
+    const normalizedInput = parseN3SourceList(input, {
+      baseIri: runOpts.baseIri || null,
+      rdf: !!runOpts.rdf,
+      sourceLocations: !!runOpts.proof,
+    }) || (await normalizeReasonerInputAsync(input));
+    return reasonStream(normalizedInput, runOpts);
+  }
+
+  const store = await createFactStore(storeConfig);
+  let closeStore = true;
+  try {
+    const parsed = await __parseRunAsyncInput(input, runOpts);
+
+    // Persist the newly supplied explicit facts first, then include all stored
+    // facts as the starting closure for this run.  This lets --store reuse facts
+    // across runs while keeping the current in-memory prover semantics intact.
+    await store.batchAdd(parsed.triples || [], 'explicit');
+    const storedTriples = await collectStore(store);
+
+    const storedKeys = new Set();
+    for (const tr of storedTriples) storedKeys.add(require('./store').tripleToStoreKey(tr));
+    const mergedTriples = storedTriples.slice();
+    for (const tr of parsed.triples || []) {
+      const key = require('./store').tripleToStoreKey(tr);
+      if (!storedKeys.has(key)) {
+        storedKeys.add(key);
+        mergedTriples.push(tr);
+      }
+    }
+
+    const result = reasonStream(
+      {
+        prefixes: parsed.prefixes,
+        triples: mergedTriples,
+        frules: parsed.frules,
+        brules: parsed.brules,
+        logQueryRules: parsed.logQueryRules,
+      },
+      runOpts,
+    );
+
+    await store.batchAdd((result.derived || []).map((df) => df.fact), 'inferred');
+    result.store = store;
+    closeStore = false;
+    return result;
+  } catch (e) {
+    await store.close();
+    throw e;
+  } finally {
+    // Keep result.store usable for callers.  On exceptional paths it is closed
+    // above; on success callers may close it when they are done.
+    if (closeStore) {
+      try { await store.close(); } catch {}
+    }
+  }
+}
+
 function reasonRdfJs(input, opts = {}) {
   const { dataFactory = null, skipUnsupportedRdfJs = false, ...restOpts } = opts || {};
   const rdfFactory = getDataFactory(dataFactory);
@@ -3890,6 +4164,8 @@ function setTracePrefixes(v) {
 
 module.exports = {
   reasonStream,
+  runAsync,
+  runStoreBacked,
   reasonRdfJs,
   collectLogQueryConclusions,
   forwardChainAndCollectLogQueryConclusions,
@@ -3926,4 +4202,7 @@ module.exports = {
   loadBuiltinModule,
   listBuiltinIris,
   INFERENCE_FUSE_EXIT_CODE,
+  createFactStore,
+  MemoryFactStore,
+  PersistentFactStore,
 };

package/lib/entry.js

@@ -17,6 +17,7 @@ const { dataFactory } = require('./rdfjs');
 module.exports = {
   // public
   reasonStream: engine.reasonStream,
+  runAsync: engine.runAsync,
   reasonRdfJs: engine.reasonRdfJs,
   rdfjs: dataFactory,
   main: engine.main,
@@ -41,6 +42,9 @@ module.exports = {
   registerBuiltinModule: engine.registerBuiltinModule,
   loadBuiltinModule: engine.loadBuiltinModule,
   listBuiltinIris: engine.listBuiltinIris,
+  createFactStore: engine.createFactStore,
+  MemoryFactStore: engine.MemoryFactStore,
+  PersistentFactStore: engine.PersistentFactStore,
   getEnforceHttpsEnabled: engine.getEnforceHttpsEnabled,
   setEnforceHttpsEnabled: engine.setEnforceHttpsEnabled,
   getProofCommentsEnabled: engine.getProofCommentsEnabled,

package/lib/rdfjs.js

@@ -952,6 +952,7 @@ module.exports = {
   internalTripleToRdfJsQuads,
   internalTripleToRdfJsQuadInGraph,
   normalizeParsedReasonerInputSync,
+  normalizeParsedReasonerInputAsync,
   normalizeReasonerInputSync,
   normalizeReasonerInputAsync,
   hasEyelingObjectInput,