From 2bcc698e2df17edaad970076525fd4f7882ab764 Mon Sep 17 00:00:00 2001 From: Tomasz Pluskiewicz Date: Tue, 31 Mar 2020 23:24:51 +0200 Subject: [PATCH] update sparql-http-client to v2.2 (#43529) * wip: sparql-http-client 2.0 * update to sparql-http-client 2.2 --- types/sparql-http-client/BaseClient.d.ts | 10 + types/sparql-http-client/Endpoint.d.ts | 48 +++++ types/sparql-http-client/ParsingClient.d.ts | 15 ++ types/sparql-http-client/ParsingQuery.d.ts | 19 ++ types/sparql-http-client/RawQuery.d.ts | 17 ++ types/sparql-http-client/ResultParser.d.ts | 16 ++ types/sparql-http-client/StreamClient.d.ts | 67 ++++++ types/sparql-http-client/StreamQuery.d.ts | 23 ++ types/sparql-http-client/StreamStore.d.ts | 20 ++ types/sparql-http-client/index.d.ts | 50 +---- .../sparql-http-client-tests.ts | 203 ++++++++++++++---- 11 files changed, 396 insertions(+), 92 deletions(-) create mode 100644 types/sparql-http-client/BaseClient.d.ts create mode 100644 types/sparql-http-client/Endpoint.d.ts create mode 100644 types/sparql-http-client/ParsingClient.d.ts create mode 100644 types/sparql-http-client/ParsingQuery.d.ts create mode 100644 types/sparql-http-client/RawQuery.d.ts create mode 100644 types/sparql-http-client/ResultParser.d.ts create mode 100644 types/sparql-http-client/StreamClient.d.ts create mode 100644 types/sparql-http-client/StreamQuery.d.ts create mode 100644 types/sparql-http-client/StreamStore.d.ts diff --git a/types/sparql-http-client/BaseClient.d.ts b/types/sparql-http-client/BaseClient.d.ts new file mode 100644 index 0000000000..e8a2f26771 --- /dev/null +++ b/types/sparql-http-client/BaseClient.d.ts @@ -0,0 +1,10 @@ +import { BaseQuad, Quad } from 'rdf-js'; +import { Client, ClientOptions, Query, Store } from '.'; + +declare class BaseClient = never> implements Client { + constructor(options: ClientOptions); + query: TQuery; + store: TStore; +} + +export = BaseClient; diff --git a/types/sparql-http-client/Endpoint.d.ts b/types/sparql-http-client/Endpoint.d.ts new file mode 100644 index 0000000000..a937894a0f --- /dev/null +++ b/types/sparql-http-client/Endpoint.d.ts @@ -0,0 +1,48 @@ +declare namespace Endpoint { + interface EndpointOptions { + endpointUrl: string; + fetch?: typeof fetch; + headers?: HeadersInit; + password?: string; + storeUrl?: string; + updateUrl?: string; + user?: string; + } + + interface RequestOptions { + headers?: HeadersInit; + update?: boolean; + } + + interface Endpoint { + endpointUrl: string; + fetch: typeof fetch; + headers: HeadersInit; + password?: string; + storeUrl?: string; + updateUrl?: string; + user?: string; + + get(query: string, options?: RequestOptions): Promise; + postDirect(query: string, options?: RequestOptions): Promise; + postUrlencoded(query: string, options?: RequestOptions): Promise; + mergeHeaders(args?: HeadersInit): Headers; + } +} + +declare class Endpoint implements Endpoint.Endpoint { + constructor(options: Endpoint.EndpointOptions); + endpointUrl: string; + fetch: typeof fetch; + headers: HeadersInit; + password?: string; + storeUrl?: string; + updateUrl?: string; + user?: string; + get(query: string, options?: Endpoint.RequestOptions): Promise; + postDirect(query: string, options?: Endpoint.RequestOptions): Promise; + postUrlencoded(query: string, options?: Endpoint.RequestOptions): Promise; + mergeHeaders(args?: HeadersInit): Headers; +} + +export = Endpoint; diff --git a/types/sparql-http-client/ParsingClient.d.ts b/types/sparql-http-client/ParsingClient.d.ts new file mode 100644 index 0000000000..40dff70af1 --- /dev/null +++ b/types/sparql-http-client/ParsingClient.d.ts @@ -0,0 +1,15 @@ +import { BaseQuad, Quad } from 'rdf-js'; +import BaseClient = require('./BaseClient'); +import { EndpointOptions } from './Endpoint'; +import { ClientOptions, Client } from '.'; +import { ParsingQuery } from './ParsingQuery'; + +declare namespace ParsingClient { + type ParsingClientOptions = EndpointOptions & Pick, 'factory'>; +} + +declare class ParsingClient extends BaseClient, Q> implements Client, Q> { + constructor(options: ParsingClient.ParsingClientOptions); +} + +export = ParsingClient; diff --git a/types/sparql-http-client/ParsingQuery.d.ts b/types/sparql-http-client/ParsingQuery.d.ts new file mode 100644 index 0000000000..ab9466bfa8 --- /dev/null +++ b/types/sparql-http-client/ParsingQuery.d.ts @@ -0,0 +1,19 @@ +import { Quad, BaseQuad } from 'rdf-js'; +import { QueryOptions, Query, QueryInit } from '.'; +import { Endpoint } from './Endpoint'; +import { ResultRow } from './ResultParser'; + +declare namespace ParsingQuery { + type ParsingQuery = Query; +} + +declare class ParsingQuery implements ParsingQuery.ParsingQuery { + constructor(options: QueryInit); + endpoint: Endpoint; + ask(query: string, options?: QueryOptions): Promise; + construct(query: string, options?: QueryOptions): Promise; + select(query: string, options?: QueryOptions): Promise; + update(query: string, options?: QueryOptions): Promise; +} + +export = ParsingQuery; diff --git a/types/sparql-http-client/RawQuery.d.ts b/types/sparql-http-client/RawQuery.d.ts new file mode 100644 index 0000000000..a48270e93c --- /dev/null +++ b/types/sparql-http-client/RawQuery.d.ts @@ -0,0 +1,17 @@ +import { Endpoint } from './Endpoint'; +import { QueryOptions, QueryInit, Query } from '.'; + +declare namespace RawQuery { + type RawQuery = Query; +} + +declare class RawQuery { + constructor(options: QueryInit); + endpoint: Endpoint; + ask(query: string, options?: QueryOptions): Promise; + construct(query: string, options?: QueryOptions): Promise; + select(query: string, options?: QueryOptions): Promise; + update(query: string, options?: QueryOptions): Promise; +} + +export = RawQuery; diff --git a/types/sparql-http-client/ResultParser.d.ts b/types/sparql-http-client/ResultParser.d.ts new file mode 100644 index 0000000000..e7eed72022 --- /dev/null +++ b/types/sparql-http-client/ResultParser.d.ts @@ -0,0 +1,16 @@ +import { Duplex } from 'stream'; +import { DataFactory, BaseQuad, Quad, Term } from 'rdf-js'; + +declare namespace ResultParser { + type ResultRow = Record; + + interface ResultParserInit { + factory: DataFactory; + } +} + +declare class ResultParser extends Duplex { + constructor(options?: ResultParser.ResultParserInit) +} + +export = ResultParser; diff --git a/types/sparql-http-client/StreamClient.d.ts b/types/sparql-http-client/StreamClient.d.ts new file mode 100644 index 0000000000..9419d6dea8 --- /dev/null +++ b/types/sparql-http-client/StreamClient.d.ts @@ -0,0 +1,67 @@ +import { BaseQuad, Quad, DataFactory, Stream } from 'rdf-js'; +import BaseClient = require('./BaseClient'); +import StreamQuery = require('./StreamQuery'); +import StreamStore = require('./StreamStore'); +import { Endpoint, EndpointOptions } from './Endpoint'; + +interface Constructor { + new (options: { endpoint: Endpoint; factory: DataFactory; }): T; +} + +declare namespace StreamClient { + interface QueryOptions { + headers?: HeadersInit; + operation?: 'get' | 'postUrlencoded' | 'postDirect'; + } + + interface QueryInit { + endpoint: Endpoint; + } + + interface SelectQuery { + select(query: string, options?: QueryOptions): Promise; + } + + interface ConstructQuery { + construct(query: string, options?: QueryOptions): Promise; + } + + interface AskQuery { + ask(query: string, options?: QueryOptions): Promise; + } + + interface UpdateQuery { + update(query: string, options?: QueryOptions): Promise; + } + + interface Query extends AskQuery, SelectQuery, ConstructQuery, UpdateQuery { + endpoint: Endpoint; + } + + interface Store { + endpoint: Endpoint; + get(graph: Quad['graph']): Promise>; + post(stream: Stream): Promise; + put(stream: Stream): Promise; + } + + interface ClientOptions = never> { + endpoint: Endpoint; + factory?: DataFactory; + Query?: Constructor; + Store?: Constructor; + } + + type StreamClientOptions = EndpointOptions & Pick>, 'factory'>; + + interface Client = never> { + query: TQuery; + store: TStore; + } +} + +declare class StreamClient extends BaseClient, Q, StreamStore> implements StreamClient.Client, Q, StreamStore> { + constructor(options: StreamClient.StreamClientOptions) +} + +export = StreamClient; diff --git a/types/sparql-http-client/StreamQuery.d.ts b/types/sparql-http-client/StreamQuery.d.ts new file mode 100644 index 0000000000..d0b2a6850d --- /dev/null +++ b/types/sparql-http-client/StreamQuery.d.ts @@ -0,0 +1,23 @@ +import { DataFactory, BaseQuad, Quad, Stream } from 'rdf-js'; +import { QueryOptions, Query, QueryInit } from '.'; +import { Endpoint } from './Endpoint'; +import { Readable } from 'stream'; + +declare namespace StreamQuery { + interface StreamQueryInit extends QueryInit { + factory?: DataFactory; + } + + type StreamQuery = Query, Readable, void>; +} + +declare class StreamQuery implements StreamQuery.StreamQuery { + constructor(options: StreamQuery.StreamQueryInit); + endpoint: Endpoint; + ask(query: string, options?: QueryOptions): Promise; + construct(query: string, options?: QueryOptions): Promise>; + select(query: string, options?: QueryOptions): Promise; + update(query: string, options?: QueryOptions): Promise; +} + +export = StreamQuery; diff --git a/types/sparql-http-client/StreamStore.d.ts b/types/sparql-http-client/StreamStore.d.ts new file mode 100644 index 0000000000..c6267e8557 --- /dev/null +++ b/types/sparql-http-client/StreamStore.d.ts @@ -0,0 +1,20 @@ +import { Store } from "./"; +import { BaseQuad, Quad, DataFactory, Stream } from "rdf-js"; +import Endpoint = require("./Endpoint"); + +declare namespace StreamStore { + interface StreamStoreInit { + endpoint: Endpoint; + factor?: DataFactory; + } +} + +declare class StreamStore implements Store { + constructor(options: StreamStore.StreamStoreInit) + endpoint: Endpoint; + get(graph: Quad['graph']): Promise>; + post(stream: Stream): Promise; + put(stream: Stream): Promise; +} + +export = StreamStore; diff --git a/types/sparql-http-client/index.d.ts b/types/sparql-http-client/index.d.ts index 3a26bd58e1..d2714f38b0 100644 --- a/types/sparql-http-client/index.d.ts +++ b/types/sparql-http-client/index.d.ts @@ -1,53 +1,9 @@ -// Type definitions for sparql-http-client 1.2 +// Type definitions for sparql-http-client 2.2 // Project: https://github.com/zazuko/sparql-http-client // Definitions by: Tomasz Pluskiewicz // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped // TypeScript Version: 2.6 -import { Term } from 'rdf-js'; -import { URL } from 'url'; +import Client = require('./StreamClient'); -declare namespace SparqlHttp { - interface SparqlHttpClient { - updateQuery(query: string, options?: QueryRequestInit): Promise; - selectQuery(query: string, options?: QueryRequestInit): Promise; - constructQuery(query: string, options?: QueryRequestInit): Promise; - } - - interface SparqlHttpOptions { - endpointUrl?: string; - updateUrl?: string; - } - - interface SparqlClientOptions extends SparqlHttpOptions { - fetch?: typeof fetch; - URL?: typeof URL; - defaultHeaders?: HeadersInit; - } - - interface QueryRequestInit extends SparqlHttpOptions, RequestInit {} - - interface SelectBindings { - results: { bindings: ReadonlyArray> }; - } - - interface AskResult { - boolean: boolean; - } - - interface SelectResponse { - json(): Promise; - } -} - -declare class SparqlHttp implements SparqlHttp.SparqlHttpClient { - constructor(options?: SparqlHttp.SparqlClientOptions); - - updateQuery(query: string, options?: SparqlHttp.QueryRequestInit): Promise; - - selectQuery(query: string, options?: SparqlHttp.QueryRequestInit): Promise; - - constructQuery(query: string, options?: SparqlHttp.QueryRequestInit): Promise; -} - -export = SparqlHttp; +export = Client; diff --git a/types/sparql-http-client/sparql-http-client-tests.ts b/types/sparql-http-client/sparql-http-client-tests.ts index 39f68e6415..f4c57e71c1 100644 --- a/types/sparql-http-client/sparql-http-client-tests.ts +++ b/types/sparql-http-client/sparql-http-client-tests.ts @@ -1,61 +1,174 @@ -import * as SparqlHttp from 'sparql-http-client'; +import StreamClient = require('sparql-http-client'); +import Endpoint = require('sparql-http-client/Endpoint'); +import BaseClient = require('sparql-http-client/BaseClient'); +import ParsingClient = require('sparql-http-client/ParsingClient'); +import RawQuery = require('sparql-http-client/RawQuery'); +import { Client } from 'sparql-http-client'; +import { Readable } from 'stream'; +import { DataFactory, Stream, Quad, NamedNode, Term } from 'rdf-js'; -const client: SparqlHttp.SparqlHttpClient = new SparqlHttp(); +interface TestQuad extends Quad { + toCanonical(): string; +} -async function selectQuery() { - const response = await client.selectQuery('...', { - endpointUrl: 'http://example.com/endpoint', +const endpointUrl = ''; +const query = ''; +const factory: DataFactory = {}; +const headers: HeadersInit = {}; +const password: string = {}; +const user: string = {}; +const storeUrl: string = {}; +const updateUrl: string = {}; +const graph: NamedNode = {}; +const stream: Stream = {}; + +const endpoint: Endpoint = new Endpoint({ + endpointUrl, + fetch, + headers, + password, + user, + storeUrl, + updateUrl, +}); + +async function streamingClient() { + // construct + const minimalOptions: StreamClient = new StreamClient({ + endpointUrl, + }); + const fullOptions: StreamClient = new StreamClient({ + endpointUrl, + factory, + fetch, + headers, + password, + user, + storeUrl, + updateUrl, }); - const json = await response.json(); + let endpoint: Endpoint = fullOptions.query.endpoint; + endpoint = fullOptions.store.endpoint; - json.results.bindings.forEach(binding => { - console.log(`${binding.name.value} (${binding.name.termType})`); + // query.ask + const askNoOptions: boolean = await fullOptions.query.ask(query); + const askFullOptions: boolean = await fullOptions.query.ask(query, { + headers, + operation: 'postDirect' + }); + + // query.select + const selectNoOptions: Readable = await fullOptions.query.select(query); + const selectFullOptions: Readable = await fullOptions.query.select(query, { + headers, + operation: 'postUrlencoded' + }); + + // query.construct + const constructNoOptions: Stream = await fullOptions.query.construct(query); + const constructFullOptions: Stream = await fullOptions.query.construct(query, { + headers, + operation: 'get' + }); + + // query.update + const updateNoOptions: Promise = fullOptions.query.update(query); + const updateFullOptions: Promise = fullOptions.query.update(query, { + headers, + operation: 'get' + }); + + // store.get + const get: Stream = await fullOptions.store.get(graph); + + // store.put + const put: Promise = fullOptions.store.put(stream); + + // store.post + const post: Promise = fullOptions.store.post(stream); +} + +async function parsingClient() { + // construct + const minimalOptions: ParsingClient = new ParsingClient({ + endpointUrl, + }); + const fullOptions: ParsingClient = new ParsingClient({ + endpointUrl, + factory, + fetch, + headers, + password, + user, + storeUrl, + updateUrl, + }); + + const endpoint: Endpoint = fullOptions.query.endpoint; + const store: never = fullOptions.store; + + // query.ask + const askNoOptions: boolean = await fullOptions.query.ask(query); + const askFullOptions: boolean = await fullOptions.query.ask(query, { + headers, + operation: 'postDirect' + }); + + // query.select + const selectNoOptions: Array> = await fullOptions.query.select(query); + const selectFullOptions: Array> = await fullOptions.query.select(query, { + headers, + operation: 'postUrlencoded' + }); + + // query.construct + const constructNoOptions: TestQuad[] = await fullOptions.query.construct(query); + const constructFullOptions: TestQuad[] = await fullOptions.query.construct(query, { + headers, + operation: 'get' + }); + + // query.update + const updateNoOptions: Promise = fullOptions.query.update(query); + const updateFullOptions: Promise = fullOptions.query.update(query, { + headers, + operation: 'get' }); } -async function askQuery() { - const response = await client.selectQuery('...', { - endpointUrl: 'http://example.com/endpoint', +async function testBaseClient_RawQuery() { + // construct + const client: Client = new BaseClient({ + endpoint, + Query: RawQuery, }); - const json = await response.json(); - - console.log(`The answer was ${json.boolean ? 'YES' : 'NO'}`); -} - -async function constructQuery() { - const response = await client.constructQuery('...'); - - const json = await response.json(); - - console.log(`The answer was ${json.boolean ? 'YES' : 'NO'}`); -} - -async function updateQuery() { - const response = await client.constructQuery('...', { - updateUrl: 'http://example.com/endpoint', + // query.ask + const askNoOptions: Response = await client.query.ask(query); + const askFullOptions: Response = await client.query.ask(query, { + headers, + operation: 'postDirect' }); - console.log(`The update ${response.ok ? 'succeeded' : 'faield'}`); -} + // query.select + const selectNoOptions: Response = await client.query.select(query); + const selectFullOptions: Response = await client.query.select(query, { + headers, + operation: 'postUrlencoded' + }); -async function oneTimeAuth() { - const endpoint = new SparqlHttp({endpointUrl: 'http://example.com/endpoint'}); + // query.construct + const constructNoOptions: Response = await client.query.construct(query); + const constructFullOptions: Response = await client.query.construct(query, { + headers, + operation: 'get' + }); - // authorize a single query - endpoint.selectQuery('query', { - headers: { - Authorization: 'Bearer token' - } - }); -} - -async function createAuthorizedCLient() { - new SparqlHttp({ - endpointUrl: 'http://example.com/endpoint', - defaultHeaders: { - Authorization: 'Bearer token' - } + // query.update + const updateNoOptions: Response = await client.query.update(query); + const updateFullOptions: Response = await client.query.update(query, { + headers, + operation: 'get' }); }