eyereasoner 2.15.0 → 3.0.1

package/dist/index.d.ts

@@ -1,44 +1,6 @@
 /// <reference types="emscripten" />
-import { Quad } from '@rdfjs/types';
 import type { SWIPLModule } from 'swipl-wasm/dist/common';
-import { IQueryOptions } from './transformers';
 export * from './query';
 export * from './transformers';
 export declare const SWIPL: (options?: Partial<EmscriptenModule>) => Promise<SWIPLModule>;
 export { default as EYE_PVM } from './eye';
-/**
- * Executes a basic query using the EYE Reasoner and default build of SWIPL
- * @param data The data for the query as RDF/JS quads
- * @param query The query as RDF/JS quads
- * @param options The reasoner options
- *  - output: What to output with implicit queries (default: undefined)
- *  - blogic: Whether to use blogic (default: false)
- *  - outputType: The type of output, either 'string' or 'quads' (default: type of input data)
- * @returns The result of the query as RDF/JS quads
- */
-export declare function n3reasoner(data: Quad[] | string, query: Quad[] | string | undefined, options: ({
-    outputType: 'string';
-} & IQueryOptions)): Promise<string>;
-export declare function n3reasoner(data: Quad[] | string, query: Quad[] | string | undefined, options: ({
-    outputType: 'quads';
-} & IQueryOptions)): Promise<Quad[]>;
-export declare function n3reasoner(data: Quad[], query: Quad[] | string | undefined, options?: ({
-    outputType?: undefined;
-} & IQueryOptions)): Promise<Quad[]>;
-export declare function n3reasoner(data: string, query: Quad[] | string | undefined, options?: ({
-    outputType?: undefined;
-} & IQueryOptions)): Promise<string>;
-export declare function n3reasoner(data: Quad[] | string, query?: Quad[] | string | undefined, options?: IQueryOptions): Promise<Quad[] | string>;
-export declare function basicQuery(data: Quad[] | string, query: Quad[] | string | undefined, options: ({
-    outputType: 'string';
-} & IQueryOptions)): Promise<string>;
-export declare function basicQuery(data: Quad[] | string, query: Quad[] | string | undefined, options: ({
-    outputType: 'quads';
-} & IQueryOptions)): Promise<Quad[]>;
-export declare function basicQuery(data: Quad[], query: Quad[] | string | undefined, options?: ({
-    outputType?: undefined;
-} & IQueryOptions)): Promise<Quad[]>;
-export declare function basicQuery(data: string, query: Quad[] | string | undefined, options?: ({
-    outputType?: undefined;
-} & IQueryOptions)): Promise<string>;
-export declare function basicQuery(data: Quad[] | string, query?: Quad[] | string | undefined, options?: IQueryOptions): Promise<Quad[] | string>;

package/dist/index.js

@@ -18,21 +18,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.basicQuery = exports.n3reasoner = exports.EYE_PVM = exports.SWIPL = void 0;
+exports.EYE_PVM = exports.SWIPL = void 0;
 // @ts-ignore
 const swipl_bundled_temp_1 = __importDefault(require("./swipl-bundled.temp"));
-const transformers_1 = require("./transformers");
 __exportStar(require("./query"), exports);
 __exportStar(require("./transformers"), exports);
 // eslint-disable-next-line no-unused-vars
 exports.SWIPL = swipl_bundled_temp_1.default;
 var eye_1 = require("./eye");
 Object.defineProperty(exports, "EYE_PVM", { enumerable: true, get: function () { return __importDefault(eye_1).default; } });
-function n3reasoner(data, query, options) {
-    return (0, transformers_1.executeBasicEyeQuery)(swipl_bundled_temp_1.default, data, query, options);
-}
-exports.n3reasoner = n3reasoner;
-function basicQuery(data, query, options = {}) {
-    return n3reasoner(data, query, { output: query ? undefined : 'deductive_closure', ...options });
-}
-exports.basicQuery = basicQuery;

package/dist/query.js

@@ -9,7 +9,9 @@ exports.queryOnce = exports.query = void 0;
  * @returns The result of the query
  */
 function query(Module, name, args) {
-    const queryString = `${name}(${typeof args === 'string'
+    const queryString = `${name}(${
+    /* istanbul ignore next */
+    typeof args === 'string'
         ? `"${args}"`
         : `[${args.map((arg) => `'${arg}'`).join(', ')}]`}).`;
     return Module.prolog.query(queryString);

package/dist/strToBuffer.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.strToBuffer = void 0;
 /* eslint-disable no-param-reassign,no-plusplus,no-bitwise,no-use-before-define,no-multi-assign */
+/* istanbul ignore file */
 /**
  * A function that converts a string into a buffer.
  * This is required *only* for the conversion of the inlined

package/dist/swipl-bundled.temp.d.ts

@@ -1 +1,3 @@
-declare var SWIPL: (SWIPL: any) => any;
+import SWIPL = require('swipl-wasm/dist/common');
+
+export = SWIPL;

package/dist/swipl-bundled.temp.js

@@ -1,4 +1,5 @@
 "use strict";
+/* istanbul ignore file */
 // This file is temporary until https://github.com/rla/npm-swipl-wasm/pull/8 is released.
 // @ts-nocheck
 var SWIPL = (() => {
@@ -85,10 +86,6 @@ var SWIPL = (() => {
                 thisProgram = process["argv"][1].replace(/\\/g, "/");
             }
             arguments_ = process["argv"].slice(2);
-            process["on"]("uncaughtException", function (ex) { if (!(ex instanceof ExitStatus)) {
-                throw ex;
-            } });
-            process["on"]("unhandledRejection", function (reason) { throw reason; });
             quit_ = (status, toThrow) => { if (keepRuntimeAlive()) {
                 process["exitCode"] = status;
                 throw toThrow;

package/dist/transformers.d.ts

@@ -2,11 +2,17 @@
 import type { SWIPLModule } from 'swipl-wasm/dist/swipl/swipl';
 import { Quad } from '@rdfjs/types';
 import type SWIPL_TYPE from 'swipl-wasm/dist/common';
-export interface IQueryOptions {
-    blogic?: boolean;
+export type ICoreQueryOptions = {
+    blogic: true;
+    output?: undefined;
+} | {
+    blogic?: false;
+    output?: 'derivations' | 'deductive_closure' | 'deductive_closure_plus_rules' | 'grounded_deductive_closure_plus_rules';
+};
+export type Options = ICoreQueryOptions & {
     outputType?: 'string' | 'quads';
-    output?: undefined | 'derivations' | 'deductive_closure' | 'deductive_closure_plus_rules' | 'grounded_deductive_closure_plus_rules';
-}
+    SWIPL?: typeof SWIPL_TYPE;
+};
 export declare function loadEyeImage(swipl: typeof SWIPL_TYPE): (options?: Partial<EmscriptenModule> | undefined) => Promise<SWIPLModule>;
 /**
  * Creates default SWIPL image loaded with EYE
@@ -22,40 +28,54 @@ export declare function SwiplEye(options?: Partial<EmscriptenModule> | undefined
  *  - blogic: Whether to use blogic (default: false)
  * @returns The same SWIPL module
  */
-export declare function runQuery(Module: SWIPLModule, data: string, queryString?: string, options?: IQueryOptions): SWIPLModule;
+export declare function runQuery(Module: SWIPLModule, data: string, queryString?: string, { blogic, output }?: Options): SWIPLModule;
+export type Data = Quad[] | string;
+export type Query = Data | undefined;
 /**
- * @param swipl The base SWIPL module to use
- * @param data The data for the query (in N3 format)
- * @param query The query (in N3 format)
+ * Executes a basic query using the EYE Reasoner and default build of SWIPL
+ * @param data The data for the query as RDF/JS quads
+ * @param query The query as RDF/JS quads
  * @param options The reasoner options
  *  - output: What to output with implicit queries (default: undefined)
  *  - blogic: Whether to use blogic (default: false)
- *  - outputType: The type of output, either 'string' or 'quads' (default: 'string')
- * @returns The result of the query
+ *  - outputType: The type of output, either 'string' or 'quads' (default: type of input data)
+ *  - SWIPL: The SWIPL module to use (default: bundled SWIPL)
+ * @returns The result of the query as RDF/JS quads
  */
-export declare function executeBasicEyeQuery(swipl: typeof SWIPL_TYPE, data: Quad[] | string, query: Quad[] | string | undefined, options: {
+export declare function executeBasicEyeQuery(swipl: typeof SWIPL_TYPE, data: Data, query: Query, options: {
     outputType: 'string';
-} & IQueryOptions): Promise<string>;
-export declare function executeBasicEyeQuery(swipl: typeof SWIPL_TYPE, data: Quad[] | string, query: Quad[] | string | undefined, options: {
+} & Options): Promise<string>;
+export declare function executeBasicEyeQuery(swipl: typeof SWIPL_TYPE, data: Data, query: Query, options: {
     outputType: 'quads';
-} & IQueryOptions): Promise<Quad[]>;
-export declare function executeBasicEyeQuery(swipl: typeof SWIPL_TYPE, data: Quad[], query?: Quad[] | string | undefined, options?: {
+} & Options): Promise<Quad[]>;
+export declare function executeBasicEyeQuery(swipl: typeof SWIPL_TYPE, data: Quad[], query?: Query, options?: {
     outputType?: undefined;
-} & IQueryOptions): Promise<Quad[]>;
-export declare function executeBasicEyeQuery(swipl: typeof SWIPL_TYPE, data: string, query?: Quad[] | string | undefined, options?: {
+} & Options): Promise<Quad[]>;
+export declare function executeBasicEyeQuery(swipl: typeof SWIPL_TYPE, data: string, query?: Query, options?: {
     outputType?: undefined;
-} & IQueryOptions): Promise<string>;
-export declare function executeBasicEyeQuery(swipl: typeof SWIPL_TYPE, data: Quad[] | string, query?: Quad[] | string | undefined, options?: IQueryOptions): Promise<Quad[] | string>;
+} & Options): Promise<string>;
+export declare function executeBasicEyeQuery(swipl: typeof SWIPL_TYPE, data: Data, query?: Query, options?: Options): Promise<Quad[] | string>;
 /**
- * @deprecated Use executeBasicEyeQuery instead
- *
+ * Executes a basic query using the EYE Reasoner and default build of SWIPL
  * @param swipl The base SWIPL module to use
- * @param data The data for the query (in N3 format)
- * @param query The query (in N3 format)
+ * @param data The data for the query as RDF/JS quads
+ * @param query The query as RDF/JS quads
  * @param options The reasoner options
  *  - output: What to output with implicit queries (default: undefined)
  *  - blogic: Whether to use blogic (default: false)
- *  - outputType: The type of output, either 'string' or 'quads' (default: 'quads')
- * @returns The result of the query
+ *  - outputType: The type of output, either 'string' or 'quads' (default: type of input data)
+ * @returns The result of the query as RDF/JS quads
  */
-export declare function executeBasicEyeQueryQuads(swipl: typeof SWIPL_TYPE, data: Quad[] | string, query?: Quad[] | string | undefined, options?: Omit<IQueryOptions, 'outputType'>): Promise<Quad[]>;
+export declare function n3reasoner(data: Data, query: Query, options: {
+    outputType: 'string';
+} & Options): Promise<string>;
+export declare function n3reasoner(data: Data, query: Query, options: {
+    outputType: 'quads';
+} & Options): Promise<Quad[]>;
+export declare function n3reasoner(data: Quad[], query?: Query, options?: {
+    outputType?: undefined;
+} & Options): Promise<Quad[]>;
+export declare function n3reasoner(data: string, query?: Query, options?: {
+    outputType?: undefined;
+} & Options): Promise<string>;
+export declare function n3reasoner(data: Data, query?: Query, options?: Options): Promise<Quad[] | string>;

package/dist/transformers.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeBasicEyeQueryQuads = exports.executeBasicEyeQuery = exports.runQuery = exports.SwiplEye = exports.loadEyeImage = void 0;
+exports.n3reasoner = exports.executeBasicEyeQuery = exports.runQuery = exports.SwiplEye = exports.loadEyeImage = void 0;
 const n3_1 = require("n3");
 // @ts-ignore
 const swipl_bundled_temp_1 = __importDefault(require("./swipl-bundled.temp"));
@@ -37,58 +37,76 @@ exports.SwiplEye = SwiplEye;
  *  - blogic: Whether to use blogic (default: false)
  * @returns The same SWIPL module
  */
-function runQuery(Module, data, queryString, options) {
-    let pass;
-    switch (options?.output) {
-        case undefined:
-            break;
-        case 'derivations':
-            pass = '--pass-only-new';
-            break;
-        case 'deductive_closure':
-            pass = '--pass';
-            break;
-        case 'deductive_closure_plus_rules':
-            pass = '--pass-all';
-            break;
-        case 'grounded_deductive_closure_plus_rules':
-            pass = '--pass-all-ground';
-            break;
-        default:
-            throw new Error(`Unknown output option: ${options?.output}`);
+function runQuery(Module, data, queryString, { blogic, output } = {}) {
+    const args = ['--quiet', 'data.nq'];
+    if (blogic) {
+        if (output || queryString) {
+            throw new Error('Cannot use blogic with explicit output or query');
+        }
+        args.push('--blogic');
     }
-    const blogic = options?.blogic;
-    Module.FS.writeFile('data.nq', data);
-    if (queryString && !blogic) {
-        Module.FS.writeFile('query.nq', queryString);
+    else {
+        args.push('--nope');
+        if (queryString) {
+            if (output) {
+                throw new Error('Cannot use explicit output with explicit query');
+            }
+            Module.FS.writeFile('query.nq', queryString);
+            args.push('--query', './query.nq');
+        }
+        else {
+            switch (output) {
+                case undefined:
+                case 'derivations':
+                    args.push('--pass-only-new');
+                    break;
+                case 'deductive_closure':
+                    args.push('--pass');
+                    break;
+                case 'deductive_closure_plus_rules':
+                    args.push('--pass-all');
+                    break;
+                case 'grounded_deductive_closure_plus_rules':
+                    args.push('--pass-all-ground');
+                    break;
+                default:
+                    throw new Error(`Unknown output option: ${output}`);
+            }
+        }
     }
-    (0, query_1.queryOnce)(Module, 'main', [blogic ? '--blogic' : '--nope', '--quiet', ...(pass ? [pass] : []), 'data.nq', ...(queryString ? ['--query', './query.nq'] : [])]);
+    Module.FS.writeFile('data.nq', data);
+    (0, query_1.queryOnce)(Module, 'main', args);
     return Module;
 }
 exports.runQuery = runQuery;
+function parse(res) {
+    const parser = new n3_1.Parser({ format: 'text/n3' });
+    // Workaround for https://github.com/rdfjs/N3.js/issues/324
+    // @ts-expect-error
+    // eslint-disable-next-line no-underscore-dangle
+    parser._supportsRDFStar = true;
+    return parser.parse(res);
+}
 async function executeBasicEyeQuery(swipl, data, query, options) {
+    /* eslint-enable max-len */
     const outputType = options?.outputType;
     let res = '';
-    const Module = await loadEyeImage(swipl)({ print: (str) => { res += `${str}\n`; } });
+    const err = [];
+    const Module = await loadEyeImage(swipl)({
+        print: (str) => { res += `${str}\n`; },
+        printErr: (str) => { err.push(str); },
+    });
     runQuery(Module, typeof data === 'string' ? data : (0, n3Writer_temp_1.write)(data), query && (typeof query === 'string' ? query : (0, n3Writer_temp_1.write)(query)), options);
+    if (err.length > 0) {
+        throw new Error(`Error while executing query: ${err.join('\n')}`);
+    }
     return (outputType === 'quads' || (typeof data !== 'string' && outputType !== 'string'))
-        ? (new n3_1.Parser({ format: 'text/n3' })).parse(res)
+        ? parse(res)
         : res;
 }
 exports.executeBasicEyeQuery = executeBasicEyeQuery;
-/**
- * @deprecated Use executeBasicEyeQuery instead
- *
- * @param swipl The base SWIPL module to use
- * @param data The data for the query (in N3 format)
- * @param query The query (in N3 format)
- * @param options The reasoner options
- *  - output: What to output with implicit queries (default: undefined)
- *  - blogic: Whether to use blogic (default: false)
- *  - outputType: The type of output, either 'string' or 'quads' (default: 'quads')
- * @returns The result of the query
- */
-async function executeBasicEyeQueryQuads(swipl, data, query, options) {
-    return executeBasicEyeQuery(swipl, data, query, { ...options, outputType: 'quads' });
+async function n3reasoner(data, query, options) {
+    /* eslint-enable max-len */
+    return executeBasicEyeQuery(options?.SWIPL || swipl_bundled_temp_1.default, data, query, options);
 }
-exports.executeBasicEyeQueryQuads = executeBasicEyeQueryQuads;
+exports.n3reasoner = n3reasoner;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyereasoner",
-  "version": "2.15.0",
+  "version": "3.0.1",
   "description": "Distributing the [EYE](https://github.com/josd/eye) reasoner for browser and node using WebAssembly.",
   "main": "dist/index.js",
   "types": "dist/index.d.js",
@@ -13,10 +13,15 @@
   "scripts": {
     "test:coverage": "npm test -- --coverage",
     "test:badges": "npm run test:coverage  && jest-coverage-badges",
-    "test": "jest",
-    "lint": "eslint lib/** __tests__/** scripts/** --ext .ts",
+    "test:unit": "npm run bundle:webpack && jest",
+    "test:memory": "npm run test:memory:node && npm run test:memory:node:error && npm run test:memory:browser",
+    "test:memory:node": "node __tests_memory__/leakTest",
+    "test:memory:node:error": "node __tests_memory__/leakTestOnError",
+    "test:memory:browser": "npm run bundle:webpack && node __tests_memory__/browserLeakTest",
+    "test": "npm run test:unit && npm run test:memory",
+    "lint": "eslint lib/** __tests__/**.ts scripts/** --ext .ts",
     "lint:fix": "npm run lint -- --fix",
-    "build": "npm run eye:prepare && tsc",
+    "build": "npm run eye:prepare && tsc && rm dist/swipl-bundled.temp.d.ts && cp ./lib/swipl-bundled.temp.d.ts ./dist/swipl-bundled.temp.d.ts",
     "bundle:webpack": "webpack --config webpack.config.js",
     "bundle:latest": "ts-node scripts/post-webpack",
     "semantic-release": "semantic-release",
@@ -52,8 +57,10 @@
   },
   "homepage": "https://github.com/eyereasoner/eye-js#readme",
   "devDependencies": {
+    "@memlab/api": "^1.0.20",
     "@qiwi/semantic-release-gh-pages-plugin": "^5.2.4",
     "@rollup/plugin-commonjs": "^24.0.1",
+    "@types/express": "^4.17.17",
     "@types/fs-extra": "^11.0.1",
     "@types/jest": "^29.4.0",
     "@types/n3": "^1.10.4",
@@ -63,11 +70,15 @@
     "eslint": "^8.34.0",
     "eslint-config-airbnb-base": "^15.0.0",
     "eslint-plugin-import": "^2.27.5",
+    "express": "^4.18.2",
+    "express-rate-limit": "^6.7.0",
     "fs-extra": "^11.1.0",
     "jest": "^29.4.2",
     "jest-environment-jsdom": "^29.4.2",
+    "jest-mock-console": "^2.0.0",
     "jest-rdf": "^1.8.0",
     "parse-url": "^8.1.0",
+    "playwright": "^1.30.0",
     "pre-commit": "^1.2.2",
     "semantic-release": "^20.1.0",
     "ts-jest": "^29.0.5",
@@ -82,7 +93,7 @@
   "pre-commit": [
     "lint",
     "build",
-    "test"
+    "test:unit"
   ],
   "release": {
     "branches": [
@@ -122,8 +133,8 @@
   },
   "config": {
     "eye": {
-      "name": "v2.12.0",
-      "url": "https://api.github.com/repos/eyereasoner/eye/releases/92625267"
+      "name": "v2.12.2",
+      "url": "https://api.github.com/repos/eyereasoner/eye/releases/92865042"
     }
   },
   "dependencies": {