[REF] Extract DataProcessor into an interface

Author: Fletcher91

src/LinkedDataAPI.ts

@@ -5,10 +5,8 @@ import {
 } from "rdflib";
 
 import {
-    DataProcessor,
     DataProcessorOpts,
-    emptyRequest,
-} from "./processor/DataProcessor";
+} from "./types";
 import {
     DataTuple,
     EmptyRequestStatus,
@@ -18,31 +16,16 @@ import {
     SomeNode,
 } from "./types";
 
-export interface LinkedDataAPIOpts {
-    dataProcessorOpts?: DataProcessorOpts;
-    processor?: DataProcessor;
-}
-
-export class LinkedDataAPI {
-    private processor: DataProcessor;
-
-    public constructor(opts: LinkedDataAPIOpts) {
-        this.processor = opts.processor || new DataProcessor(opts.dataProcessorOpts);
-    }
-
-    public execActionByIRI(subject: NamedNode, dataTuple: DataTuple): Promise<LinkedActionResponse> {
-        return this.processor.execActionByIRI(subject, dataTuple);
-    }
+export interface LinkedDataAPI {
+    execActionByIRI(subject: NamedNode, dataTuple: DataTuple): Promise<LinkedActionResponse>;
 
     /**
      * Loads a resource from the {iri}.
      * @param iri The SomeNode of the resource
      * @return The response from the server, or an response object from
      * the extension
      */
-    public fetchResource(iri: NamedNode): Promise<Response | object> {
-        return this.processor.fetchResource(iri);
-    }
+    fetchResource(iri: NamedNode): Promise<Response | object>;
 
     /**
      * Gets an entity by its SomeNode.
@@ -53,9 +36,7 @@ export class LinkedDataAPI {
      * @param opts The options for fetch-/processing the resource.
      * @return A promise with the resulting entity
      */
-    public getEntity(iri: NamedNode, opts?: FetchOpts): Promise<Statement[]> {
-        return this.processor.getEntity(iri, opts);
-    }
+    getEntity(iri: NamedNode, opts?: FetchOpts): Promise<Statement[]>;
 
     /**
      * Retrieve the (network) status for a resource.
@@ -74,28 +55,22 @@ export class LinkedDataAPI {
      * @param {SomeNode} iri The resource to get the status on.
      * @return {EmptyRequestStatus | FulfilledRequestStatus}
      */
-    public getStatus(iri: SomeNode): EmptyRequestStatus | FulfilledRequestStatus {
-        if (iri.termType === "BlankNode") {
-            return emptyRequest as EmptyRequestStatus;
-        }
-
-        return this.processor.getStatus(iri);
-    }
+    getStatus(iri: SomeNode): EmptyRequestStatus | FulfilledRequestStatus;
 
     /** Register a transformer so it can be used to interact with API's. */
-    public registerTransformer(processor: ResponseTransformer,
-                               mediaType: string | string[],
-                               acceptValue: number): void {
-        const mediaTypes: string[] = Array.isArray(mediaType) ? mediaType : [mediaType];
-        this.processor.registerTransformer(processor, mediaTypes, acceptValue);
-    }
+    registerTransformer(processor: ResponseTransformer,
+                        mediaType: string | string[],
+                        acceptValue: number): void;
 
     /**
      * Overrides the `Accept` value for when a certain host doesn't respond well to multiple values.
      * @param origin The iri of the origin for the requests.
      * @param acceptValue The value to use for the `Accept` header.
      */
-    public setAcceptForHost(origin: string, acceptValue: string): void {
-        this.processor.setAcceptForHost(origin, acceptValue);
-    }
+    setAcceptForHost(origin: string, acceptValue: string): void;
 }
+
+declare var LinkedDataAPI: {
+    new (opts?: DataProcessorOpts): any;
+    (): any;
+};

src/LinkedRenderStore.ts

@@ -10,6 +10,7 @@ import {
 
 import { ComponentStore } from "./ComponentStore";
 import { LinkedDataAPI } from "./LinkedDataAPI";
+import { DataProcessor, emptyRequest } from "./processor/DataProcessor";
 import { dataToGraphTuple } from "./processor/DataToGraph";
 import { RDFStore } from "./RDFStore";
 import { Schema } from "./Schema";
@@ -72,11 +73,9 @@ export class LinkedRenderStore<T> {
             this.store = opts.store;
         }
 
-        this.api = opts.api || new LinkedDataAPI({
-            dataProcessorOpts: {
-                requestNotifier: this.touch.bind(this),
-                store: this.store,
-            },
+        this.api = opts.api || new DataProcessor({
+            requestNotifier: this.touch.bind(this),
+            store: this.store,
         });
         this.defaultType = opts.defaultType || defaultNS.schema("Thing");
         this.namespaces = opts.namespaces || {...defaultNS};
@@ -239,6 +238,10 @@ export class LinkedRenderStore<T> {
     }
 
     public getStatus(iri: SomeNode): EmptyRequestStatus | FulfilledRequestStatus {
+        if (iri.termType === "BlankNode") {
+            return emptyRequest as EmptyRequestStatus;
+        }
+
         return this.api.getStatus(iri);
     }
 

src/__tests__/LinkedDataAPI.spec.ts

@@ -15,9 +15,11 @@ import {
     Statement,
     uri as Uri,
 } from "rdflib";
+import { LinkedDataAPI } from "../LinkedDataAPI";
 
 import { RDFStore } from "../RDFStore";
 import {
+    DataProcessorOpts,
     DataTuple,
     EmptyRequestStatus,
     FailedResponse,
@@ -114,15 +116,6 @@ function processResponse(iri: string | NamedNode, res: Response): Statement[] {
     return [];
 }
 
-export interface DataProcessorOpts {
-    accept?: { [k: string]: string };
-    requestInitGenerator?: RequestInitGenerator;
-    fetcher?: Fetcher;
-    mapping?: { [k: string]: ResponseTransformer[] };
-    requestNotifier?: RequestCallbackHandler;
-    store: RDFStore;
-}
-
 export const emptyRequest = Object.freeze({
     lastRequested: null,
     requested: false,
@@ -147,7 +140,7 @@ const timedOutRequest = (totalRequested: number): FulfilledRequestStatus => Obje
     timesRequested: totalRequested,
 }) as FulfilledRequestStatus;
 
-export class DataProcessor {
+export class DataProcessor implements LinkedDataAPI {
     public accept: { [k: string]: string };
     public timeout: number = 30000;
 

src/processor/DataProcessor.ts

@@ -32,7 +32,7 @@ export type GetBasicStoreOpts = Partial<ExplodedLRS<BasicComponent>>;
 export const getBasicStore = (opts: GetBasicStoreOpts  = {}): ExplodedLRS<BasicComponent> => {
     const store = opts.store || new RDFStore();
     const processor = opts.processor || new DataProcessor({ store });
-    const api = opts.api || new LinkedDataAPI({ processor });
+    const api = opts.api || processor;
     const schema = opts.schema || new Schema(store);
     const mapping = opts.mapping || new ComponentStoreTestProxy<BasicComponent>(schema);
 

src/testUtilities.ts

@@ -1,16 +1,19 @@
 import {
     BlankNode,
+    Fetcher,
     IndexedFormula,
     Literal,
     NamedNamespace,
     NamedNode,
+    RequestCallbackHandler,
     SomeTerm,
     Statement,
 } from "rdflib";
 
 import { ComponentStore } from "./ComponentStore";
 import { LinkedDataAPI } from "./LinkedDataAPI";
 import { LinkedRenderStore } from "./LinkedRenderStore";
+import { RequestInitGenerator } from "./processor/RequestInitGenerator";
 import { RDFStore } from "./RDFStore";
 import { Schema } from "./Schema";
 import { DisjointSet } from "./utilities/DisjointSet";
@@ -161,3 +164,12 @@ export interface VocabularyProcessor {
      */
     processType: (type: NamedNode, ctx: VocabularyProcessingContext) => boolean;
 }
+
+export interface DataProcessorOpts {
+    accept?: { [k: string]: string };
+    requestInitGenerator?: RequestInitGenerator;
+    fetcher?: Fetcher;
+    mapping?: { [k: string]: ResponseTransformer[] };
+    requestNotifier?: RequestCallbackHandler;
+    store: RDFStore;
+}