Updates to dependencies and GitHub actions, and code clean-up

* Move from TSLint to ESLint, use yarn@4.1.1, bump dependencies

* Fixes to linting errors in code, typing, and error handling

* Update unit tests

* Revert result type changes

* Revert to yarn@1.22.22 for Node 16

* Revert customFetch to fetchCb to avoid major version

* Remove additional helper type for fetch

* Add timeout test for fetchRawStream

* Remove unnecessary .yarnrc.yml

* Fix eslint version in package, add missing newline

* Add @types/n3 to dependencies since they end up in index.d.ts

* Use version 3 of @rubensworks/eslint-config

* Remove rule overrides

* Add project-specific exceptions to rules

* Fix linter errors

* Add --ignore-engines flag due to new linter rules

* Add back ReadableStream workaround for Node 16

* Move readable-stream-node-to-web import below the ReadableStream workaround

* Fix AbortController timeout test on Node 16

* Fix additional URL params on Node 16

* Fix url params size check on Node 16

* Restore CLI tool to previous usage options

* Fix CLI usage in test-docker.sh

* Remove matrix from Docker step and rename it

* Make --query optional again

* Use version 2 of coveralls action instead of master branch

* Add back return type annotation for getQueryType

---------

Co-authored-by: surilindur <surilindur@users.noreply.github.com>

Author: surilindur

.github/workflows/ci.yml

@@ -22,7 +22,7 @@ jobs:
         with:
           node-version: 20.x
       - run: corepack enable
-      - run: yarn install --frozen-lockfile
+      - run: yarn install --ignore-engines --frozen-lockfile
       - run: yarn run lint
 
   test:
@@ -47,10 +47,10 @@ jobs:
           path: '**/node_modules'
           key: ${{ runner.os }}-test-modules-${{ hashFiles('**/yarn.lock') }}
       - run: corepack enable
-      - run: yarn install --frozen-lockfile
+      - run: yarn install --ignore-engines --frozen-lockfile
       - run: yarn run build
       - run: yarn run test
-      - uses: coverallsapp/github-action@master
+      - uses: coverallsapp/github-action@v2
         with:
           github-token: ${{ secrets.github_token }}
           flag-name: run-${{ matrix.node-version }}
@@ -61,24 +61,18 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Consolidate test coverage from different jobs
-        uses: coverallsapp/github-action@master
+        uses: coverallsapp/github-action@v2
         with:
           github-token: ${{ secrets.github_token }}
           parallel-finished: true
 
-  docker:
+  cli:
     needs: test
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os:
-          - ubuntu-latest
-        node-version:
-          - 20.x
+    runs-on: ubuntu-latest
     steps:
       - uses: actions/setup-node@v4
         with:
-          node-version: ${{ matrix.node-version }}
+          node-version: 20.x
       - run: git config --global core.autocrlf input
       - uses: actions/checkout@v4
       - run: .github/workflows/start-docker.sh
@@ -87,7 +81,7 @@ jobs:
           path: '**/node_modules'
           key: ${{ runner.os }}-docker-modules-${{ hashFiles('**/yarn.lock') }}
       - run: corepack enable
-      - run: yarn install --frozen-lockfile
+      - run: yarn install --ignore-engines --frozen-lockfile
       - run: yarn build
       - run: .github/workflows/test-docker.sh
       - run: .github/workflows/stop-docker.sh
@@ -105,5 +99,5 @@ jobs:
         with:
           node-version: 20.x
       - run: corepack enable
-      - run: yarn install --frozen-lockfile
+      - run: yarn install --ignore-engines --frozen-lockfile
       - run: npx webpack

README.md

@@ -32,21 +32,28 @@ This package also works out-of-the-box in browsers via tools such as [webpack](h
 #### Create a new fetcher
 
 ```js
-import {SparqlEndpointFetcher} from "fetch-sparql-endpoint";
+import { SparqlEndpointFetcher } from 'fetch-sparql-endpoint';
 
 const myFetcher = new SparqlEndpointFetcher();
 ```
 
 Optionally, you can pass an options object with the following optional entries:
 ```js
 const myFetcher = new SparqlEndpointFetcher({
-  method: 'POST',                           // A custom HTTP method for issuing (non-update) queries, defaults to POST. Update queries are always issued via POST.
-  additionalUrlParams: new URLSearchParams({'infer': 'true', 'sameAs': 'false'});  // A set of additional parameters that well be added to fetchAsk, fetchBindings & fetchTriples requests
-  defaultHeaders: new Headers(),            // Optional default headers that will be included in each request
-  fetch: fetch,                             // A custom fetch-API-supporting function
-  dataFactory: DataFactory,                 // A custom RDFJS data factory
-  prefixVariableQuestionMark: false,        // If variable names in bindings should be prefixed with '?', defaults to false
-  timeout: 5000                             // Timeout for setting up server connection (Once a connection has been made, and the response is being parsed, the timeout does not apply anymore).
+  // A custom HTTP method for issuing (non-update) queries, defaults to POST. Update queries are always issued via POST.
+  method: 'POST',
+  // A set of additional parameters that well be added to fetchAsk, fetchBindings & fetchTriples requests
+  additionalUrlParams: new URLSearchParams({ infer: 'true', sameAs: 'false' }),
+  // Optional default headers that will be included in each request
+  defaultHeaders: new Headers(),
+  // A custom fetch-API-supporting function
+  fetch,
+  // A custom RDFJS data factory
+  dataFactory: DataFactory,
+  // If variable names in bindings should be prefixed with '?', defaults to false
+  prefixVariableQuestionMark: false,
+  // Timeout for setting up server connection (Once a connection has been made, and the response is being parsed, the timeout does not apply anymore).
+  timeout: 5000,
 });
 ```
 
@@ -56,7 +63,7 @@ const myFetcher = new SparqlEndpointFetcher({
 
 ```js
 const bindingsStream = await fetcher.fetchBindings('https://dbpedia.org/sparql', 'SELECT * WHERE { ?s ?p ?o } LIMIT 100');
-bindingsStream.on('data', (bindings) => console.log(bindings));
+bindingsStream.on('data', bindings => console.log(bindings));
 ```
 
 This will output bindings in the following form,
@@ -72,9 +79,9 @@ and values and [RDFJS terms](http://rdf.js.org/#term-interface):
 Optionally, you can obtain a list of variables by listening to the `'variables'` event:
 ```js
 const bindingsStream = await fetcher.fetchBindings('https://dbpedia.org/sparql', 'SELECT * WHERE { ?s ?p ?o } LIMIT 100');
-bindingsStream.on('data', (bindings) => console.log(bindings));
+bindingsStream.on('data', bindings => console.log(bindings));
 // Will print [ variable('s'), variable('p'), variable('o') ]
-bindingsStream.on('variables', (variables) => console.log(variables));
+bindingsStream.on('variables', variables => console.log(variables));
 ```
 
 ### Fetch ask
@@ -94,7 +101,7 @@ queries returns a (promise to a) stream of triples.
 
 ```js
 const tripleStream = await fetcher.fetchTriples('https://dbpedia.org/sparql', 'CONSTRUCT { ?s ?p ?o } LIMIT 100');
-tripleStream.on('data', (triple) => console.log(triple));
+tripleStream.on('data', triple => console.log(triple));
 ```
 
 This will output [RDFJS triples](http://rdf.js.org/#triple-interface) as follows:
@@ -121,10 +128,13 @@ If you want to know the query type
 in order to determine which of the above fetch methods to call,
 then you can use the `getQueryType` method as follows:
 
-```
-fetcher.getQueryType('SELECT * WHERE { ?s ?p ?o } LIMIT 100'); // Outputs 'SELECT'
-fetcher.getQueryType('ASK WHERE { ?s ?p ?o }');                // Outputs 'ASK'
-fetcher.getQueryType('CONSTRUCT { ?s ?p ?o } LIMIT 100');      // Outputs 'CONSTRUCT'
+```js
+// Outputs 'SELECT'
+fetcher.getQueryType('SELECT * WHERE { ?s ?p ?o } LIMIT 100');
+// Outputs 'ASK'
+fetcher.getQueryType('ASK WHERE { ?s ?p ?o }');
+// Outputs 'CONSTRUCT'
+fetcher.getQueryType('CONSTRUCT { ?s ?p ?o } LIMIT 100');
 ```
 
 This method will also throw an error if the query contains a syntax error.

bin/fetch-sparql-endpoint.ts

@@ -1,121 +1,111 @@
 #!/usr/bin/env node
 
-import {readFileSync} from "fs";
-import minimist = require("minimist");
-import {quadToStringQuad, termToString} from "rdf-string";
-import {SparqlEndpointFetcher} from "../index";
+import { readFileSync } from 'node:fs';
+import { StreamWriter } from 'n3';
+import { termToString } from 'rdf-string';
+import * as streamToString from 'stream-to-string';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { SparqlEndpointFetcher, type IBindings } from '..';
 
-// tslint:disable-next-line:no-var-requires
-const n3 = require('n3');
-
-process.argv.splice(0, 2);
-const args = minimist(process.argv);
-if (args._.length === 0 || args._.length > 2 || args.h || args.help) {
-
-  // Print command usage
-  process.stderr.write(`fetch-sparql-endpoint Sends a query to a SPARQL endpoint
-
-Usage:
-  fetch-sparql-endpoint https://dbpedia.org/sparql [-q] 'SELECT * WHERE { ?s ?p ?o } 100'
-  fetch-sparql-endpoint https://dbpedia.org/sparql -f query.sparql
-  cat query.sparql | fetch-sparql-endpoint https://dbpedia.org/sparql
-
-Options:
-  -q            evaluate the given SPARQL query string
-  -f            evaluate the SPARQL query in the given file
-  -g            send query via HTTP GET instead of POST
-  --help        print this help message
-`);
-  process.exit(1);
-}
-
-async function getQuery(): Promise<string> {
-  if (args._.length > 1) {
-    return args._[1];
-  } else if (args.q) {
-    return args.q;
-  } else if (args.f) {
-    return readFileSync(args.f, { encoding: 'utf8' });
-  } else {
-    // tslint:disable-next-line:no-var-requires
-    return await require('stream-to-string')(process.stdin);
+async function getQuery(query?: string, file?: string): Promise<string> {
+  if (query) {
+    return query;
   }
+  if (file) {
+    readFileSync(file, { encoding: 'utf-8' });
+  }
+  return streamToString(process.stdin);
 }
 
-const endpoint = args._[0];
-
-getQuery().then((query) => {
-  const fetcher = new SparqlEndpointFetcher({
-    method: args.g ? 'GET' : 'POST',
+function querySelect(endpoint: string, fetcher: SparqlEndpointFetcher, query: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    fetcher.fetchBindings(endpoint, query).then(bindingsStream => bindingsStream
+      .on('data', (bindings: IBindings) => {
+        process.stdout.write(`${JSON.stringify(Object.fromEntries(Object.entries(bindings).map(([ key, value ]) => [
+          key,
+          termToString(value),
+        ])))}\n`);
+      })
+      .on('error', reject)
+      .on('end', resolve)).catch(reject);
   });
-  const queryType = fetcher.getQueryType(query);
-  switch (queryType) {
-  case 'SELECT':
-    querySelect(fetcher, query);
-    break;
-  case 'ASK':
-    queryAsk(fetcher, query);
-    break;
-  case 'CONSTRUCT':
-    queryConstruct(fetcher, query);
-    break;
-  case 'UNKNOWN':
-    if (fetcher.getUpdateTypes(query) !== 'UNKNOWN') {
-      update(fetcher, query);
-    }
-    break;
-  }
-});
-
-function querySelect(fetcher: SparqlEndpointFetcher, query: string) {
-  fetcher.fetchBindings(endpoint, query)
-    .then((bindingsStream) => {
-      bindingsStream.on('data', (bindings) => {
-        for (const variable of Object.keys(bindings)) {
-          bindings[variable] = termToString(bindings[variable]);
-        }
-        process.stdout.write(JSON.stringify(bindings) + '\n');
-      });
-      bindingsStream.on('error', (error) => process.stderr.write(error.toString()));
-    })
-    .catch((error) => {
-      process.stderr.write(error.message + '\n');
-      process.exit(1);
-    });
 }
 
-function queryAsk(fetcher: SparqlEndpointFetcher, query: string) {
-  fetcher.fetchAsk(endpoint, query)
-    .then((answer) => {
-      process.stdout.write(answer + '\n');
-    })
-    .catch((error) => {
-      process.stderr.write(error.message + '\n');
-      process.exit(1);
-    });
+function queryAsk(endpoint: string, fetcher: SparqlEndpointFetcher, query: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    fetcher.fetchAsk(endpoint, query)
+      .then((answer) => {
+        process.stdout.write(`${answer}\n`);
+        resolve();
+      })
+      .catch(reject);
+  });
 }
 
-function queryConstruct(fetcher: SparqlEndpointFetcher, query: string) {
-  fetcher.fetchTriples(endpoint, query)
-    .then((tripleStream) => {
-      (<any> tripleStream)
-        .on('error', (error: Error) => process.stderr.write(error.toString()))
-        .pipe(new n3.StreamWriter(SparqlEndpointFetcher.CONTENTTYPE_TURTLE))
-        .pipe(process.stdout);
-    })
-    .catch((error) => {
-      process.stderr.write(error.message + '\n');
-      process.exit(1);
-    });
+function queryConstruct(endpoint: string, fetcher: SparqlEndpointFetcher, query: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    fetcher.fetchTriples(endpoint, query)
+      .then(tripleStream => tripleStream
+        .on('error', reject)
+        .pipe(new StreamWriter(SparqlEndpointFetcher.CONTENTTYPE_TURTLE))
+        .pipe(process.stdout)
+        .on('end', resolve)).catch(reject);
+  });
 }
 
-function update(fetcher: SparqlEndpointFetcher, query: string) {
-  fetcher.fetchUpdate(endpoint, query)
-    .then(() => {
+function update(endpoint: string, fetcher: SparqlEndpointFetcher, query: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    fetcher.fetchUpdate(endpoint, query).then(() => {
       process.stdout.write('OK\n');
+      resolve();
+    }).catch(reject);
+  });
+}
+
+async function run(argv: string[]): Promise<void> {
+  const args = await yargs(hideBin(argv))
+    .example(
+      '$0 https://dbpedia.org/sparql --query \'SELECT * WHERE { ?s ?p ?o } LIMIT 100\'',
+      'Fetch 100 triples from the DBPedia SPARQL endpoint',
+    )
+    .example(
+      '$0 https://dbpedia.org/sparql --file query.rq',
+      'Run the SPARQL query from query.rq against the DBPedia SPARQL endpoint',
+    )
+    .example(
+      'cat query.rq | $0 https://dbpedia.org/sparql',
+      'Run the SPARQL query from query.rq against the DBPedia SPARQL endpoint',
+    )
+    .positional('endpoint', { type: 'string', describe: 'Send the query to this SPARQL endpoint', demandOption: true })
+    .positional('query', { type: 'string', describe: 'The query to execute' })
+    .options({
+      query: { alias: 'q', type: 'string', describe: 'Evaluate the given SPARQL query string' },
+      file: { alias: 'f', type: 'string', describe: 'Evaluate the SPARQL query in the given file' },
+      get: { alias: 'g', type: 'boolean', describe: 'Send query via HTTP GET instead of POST', default: false },
     })
-    .catch((error) => {
-      process.stderr.write(error.message + '\n');
-      process.exit(1);
-    });
+    .help()
+    .parse();
+  const endpoint = <string>args._[0];
+  const queryString = await getQuery(args._.length > 1 ? <string>args._[1] : args.query, args.file);
+  const fetcher = new SparqlEndpointFetcher({ method: args.get ? 'GET' : 'POST' });
+  const queryType = fetcher.getQueryType(queryString);
+  switch (queryType) {
+    case 'SELECT':
+      await querySelect(endpoint, fetcher, queryString);
+      break;
+    case 'ASK':
+      await queryAsk(endpoint, fetcher, queryString);
+      break;
+    case 'CONSTRUCT':
+      await queryConstruct(endpoint, fetcher, queryString);
+      break;
+    case 'UNKNOWN':
+      if (fetcher.getUpdateTypes(queryString) !== 'UNKNOWN') {
+        await update(endpoint, fetcher, queryString);
+      }
+      break;
+  }
 }
+
+run(process.argv).then().catch(error => process.stderr.write(`${error.toString()}\n`));

eslint.config.js

@@ -0,0 +1,28 @@
+const config = require('@rubensworks/eslint-config');
+
+module.exports = config([
+  {
+    files: [ '**/*.ts' ],
+    languageOptions: {
+      parserOptions: {
+        tsconfigRootDir: __dirname,
+        project: [ './tsconfig.eslint.json' ],
+      },
+    },
+  },
+  {
+    files: [ '**/*.ts', 'webpack.config.js' ],
+    rules: {
+      'import/no-nodejs-modules': 'off',
+      // The naming convention rules complain about the public static properties, as well
+      'ts/naming-convention': 'off',
+    },
+  },
+  {
+    // The readme contains examples with console logging
+    files: [ 'README.md/*' ],
+    rules: {
+      'no-console': 'off',
+    },
+  },
+]);